diff --git a/renderdoc.sln b/renderdoc.sln index b04e93701..4997e4305 100644 --- a/renderdoc.sln +++ b/renderdoc.sln @@ -79,6 +79,8 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "renderdocui_stub", "qrender EndProject Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "NV", "renderdoc\driver\ihv\nv\NV.vcxproj", "{40349AD9-5558-4DF4-84E2-11934DE90A11}" EndProject +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "AMD_RGP", "renderdoc\driver\ihv\amd\AMD_RGP.vcxproj", "{B33F8FFD-3C04-4779-9C3B-E2858387971B}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Development|x64 = Development|x64 @@ -263,6 +265,14 @@ Global {40349AD9-5558-4DF4-84E2-11934DE90A11}.Release|x64.Build.0 = Release|x64 {40349AD9-5558-4DF4-84E2-11934DE90A11}.Release|x86.ActiveCfg = Release|Win32 {40349AD9-5558-4DF4-84E2-11934DE90A11}.Release|x86.Build.0 = Release|Win32 + {B33F8FFD-3C04-4779-9C3B-E2858387971B}.Development|x64.ActiveCfg = Development|x64 + {B33F8FFD-3C04-4779-9C3B-E2858387971B}.Development|x64.Build.0 = Development|x64 + {B33F8FFD-3C04-4779-9C3B-E2858387971B}.Development|x86.ActiveCfg = Development|Win32 + {B33F8FFD-3C04-4779-9C3B-E2858387971B}.Development|x86.Build.0 = Development|Win32 + {B33F8FFD-3C04-4779-9C3B-E2858387971B}.Release|x64.ActiveCfg = Release|x64 + {B33F8FFD-3C04-4779-9C3B-E2858387971B}.Release|x64.Build.0 = Release|x64 + {B33F8FFD-3C04-4779-9C3B-E2858387971B}.Release|x86.ActiveCfg = Release|Win32 + {B33F8FFD-3C04-4779-9C3B-E2858387971B}.Release|x86.Build.0 = Release|Win32 EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -296,5 +306,6 @@ Global {257FD75C-4D17-4A23-A754-23BFD85887A0} = {B5A783D9-AEB9-420D-8E77-D4D930F8D88C} {37955C79-D91D-423F-8C6C-8F5BCF4F28D4} = {B5A783D9-AEB9-420D-8E77-D4D930F8D88C} {40349AD9-5558-4DF4-84E2-11934DE90A11} = {4DA2F3E3-9A65-45DD-A69B-82C7757D4904} + {B33F8FFD-3C04-4779-9C3B-E2858387971B} = {4DA2F3E3-9A65-45DD-A69B-82C7757D4904} EndGlobalSection EndGlobal diff --git a/renderdoc/driver/ihv/amd/AMD_RGP.vcxproj b/renderdoc/driver/ihv/amd/AMD_RGP.vcxproj new file mode 100644 index 000000000..0c8f2645f --- /dev/null +++ b/renderdoc/driver/ihv/amd/AMD_RGP.vcxproj @@ -0,0 +1,234 @@ + + + + + Development + Win32 + + + Development + x64 + + + Release + Win32 + + + Release + x64 + + + + {B33F8FFD-3C04-4779-9C3B-E2858387971B} + AMD_RGP + 8.1 + + + + StaticLibrary + true + MultiByte + v140 + + + true + + + + + + + $(SolutionDir)$(Platform)\$(Configuration)\ + $(ExecutablePath) + $(SolutionDir)\breakpad;$(IncludePath) + $(LibraryPath) + $(ExcludePath) + driver_$(ProjectName) + + + $(SolutionDir)$(Platform)\$(Configuration)\obj\$(ProjectName)\ + + + + WIN64;%(PreprocessorDefinitions) + + + + + RELEASE;%(PreprocessorDefinitions) + + + + + $(ProjectDir)official\RGP\ADL\include;$(ProjectDir)official\RGP\DevDriverComponents\inc;$(SolutionDir)renderdoc\;$(SolutionDir)renderdoc\3rdparty\ + GPUOPEN_CLIENT_INTERFACE_MAJOR_VERSION=27;RENDERDOC_EXPORTS;RENDERDOC_PLATFORM_WIN32;WIN32;NDEBUG;_WINDOWS;_USRDLL;AGS;%(PreprocessorDefinitions) + Level4 + MultiThreadedDLL + false + true + true + false + ProgramDatabase + 4100;4201;4324;4189;4127;4996 + + + Windows + true + + + + + Disabled + + + + + MaxSpeed + Default + true + true + + + true + true + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + true + + + true + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/renderdoc/driver/ihv/amd/AMD_RGP.vcxproj.filters b/renderdoc/driver/ihv/amd/AMD_RGP.vcxproj.filters new file mode 100644 index 000000000..ae18532f6 --- /dev/null +++ b/renderdoc/driver/ihv/amd/AMD_RGP.vcxproj.filters @@ -0,0 +1,431 @@ + + + + + {e8f4dcfb-b6d9-4fb8-aa7b-c7ad46b29f83} + + + {7f0cc2e2-a45e-4957-a1c5-9ec2ae66396b} + + + {29abae8a-3a0f-4f0b-8092-d88ab3d9a1a4} + + + {d97a3063-2945-4ad3-a616-0eda2e187f23} + + + {ec03dc9f-8299-40a4-a6b4-004e85687996} + + + {ec3413de-c35d-4612-95ad-c48adbd42355} + + + {793454d9-d39b-41a2-9c57-61bdc79a2553} + + + {295905ef-9b24-4585-8a52-d43804268cd5} + + + {8749e3f4-7d31-434d-8ef2-1bbc47f94507} + + + {8a4afd3f-72db-4f2a-88da-222e6665577a} + + + {26f16d97-2b0c-4333-a1e4-8877e79ce5d0} + + + {5af13bf5-c069-4995-ba85-adf7ec337eed} + + + {8d594f6c-17a7-42e8-a89c-0d41552283de} + + + {09408f6a-a584-4caf-941f-9f442edd2214} + + + {7c0f2f8e-70c5-4d99-8396-0311df7e9f75} + + + + + DevDriverComponents\src\protocols + + + DevDriverComponents\src\win + + + DevDriverComponents\src\win + + + DevDriverComponents\src\win + + + DevDriverComponents\src\win + + + DevDriverComponents\src\win + + + DevDriverComponents\src + + + DevDriverComponents\src + + + DevDriverComponents\src + + + DevDriverComponents\src + + + DevDriverComponents\src + + + DevDriverComponents\src + + + DevDriverComponents\listener + + + DevDriverComponents\listener + + + DevDriverComponents\listener + + + DevDriverComponents\listener + + + DevDriverComponents\listener + + + DevDriverComponents\listener + + + DevDriverComponents\listener\transports + + + DevDriverComponents\listener\transports + + + DevDriverComponents\listener\transports + + + DevDriverComponents\listener\transports + + + DevDriverComponents\listener\clientmanagers + + + DevDriverComponents\listener\clientmanagers + + + DevDriverComponents\inc + + + DevDriverComponents\inc + + + DevDriverComponents\inc + + + DevDriverComponents\inc + + + DevDriverComponents\inc + + + DevDriverComponents\inc + + + DevDriverComponents\inc + + + DevDriverComponents\inc + + + DevDriverComponents\inc + + + DevDriverComponents\inc + + + DevDriverComponents\inc + + + DevDriverComponents\inc + + + DevDriverComponents\inc\posix + + + DevDriverComponents\inc\protocols + + + DevDriverComponents\inc\protocols + + + DevDriverComponents\inc\protocols + + + DevDriverComponents\inc\protocols + + + DevDriverComponents\inc\protocols + + + DevDriverComponents\inc\protocols + + + DevDriverComponents\inc\protocols + + + DevDriverComponents\inc\protocols + + + DevDriverComponents\inc\protocols + + + DevDriverComponents\inc\protocols + + + DevDriverComponents\inc\protocols + + + DevDriverComponents\inc\protocols + + + DevDriverComponents\inc\protocols + + + DevDriverComponents\inc\protocols + + + DevDriverComponents\inc\protocols + + + DevDriverComponents\inc\protocols + + + DevDriverComponents\inc\protocols + + + DevDriverComponents\inc\protocols + + + DevDriverComponents\inc\protocols + + + DevDriverComponents\inc\protocols + + + DevDriverComponents\inc\protocols + + + DevDriverComponents\inc\protocols + + + DevDriverComponents\inc\protocols + + + DevDriverComponents\inc\protocols + + + DevDriverComponents\inc\util + + + DevDriverComponents\inc\util + + + DevDriverComponents\inc\util + + + DevDriverComponents\inc\util + + + DevDriverComponents\inc\util + + + DevDriverComponents\inc\util + + + DevDriverComponents\inc\util + + + DevDriverComponents\inc\util + + + DevDriverComponents\inc\util + + + DevDriverComponents\inc\win + + + Common + + + Common + + + DevDriverComponents\inc + + + DevDriverComponents\inc\protocols + + + DevDriverComponents\inc\protocols + + + DevDriverComponents\src + + + DevDriverAPI + + + DevDriverAPI + + + DevDriverAPI + + + + + DevDriverComponents\src\posix + + + DevDriverComponents\src\posix + + + DevDriverComponents\src\protocols + + + DevDriverComponents\src\protocols + + + DevDriverComponents\src\protocols + + + DevDriverComponents\src\protocols + + + DevDriverComponents\src\protocols + + + DevDriverComponents\src\protocols + + + DevDriverComponents\src\protocols + + + DevDriverComponents\src\protocols + + + DevDriverComponents\src\protocols + + + DevDriverComponents\src\protocols + + + DevDriverComponents\src\protocols + + + DevDriverComponents\src\protocols + + + DevDriverComponents\src\protocols + + + DevDriverComponents\src\protocols + + + DevDriverComponents\src\protocols + + + DevDriverComponents\src\protocols + + + DevDriverComponents\src\win + + + DevDriverComponents\src\win + + + DevDriverComponents\src\win + + + DevDriverComponents\src\win + + + DevDriverComponents\src + + + DevDriverComponents\src + + + DevDriverComponents\src + + + DevDriverComponents\src + + + DevDriverComponents\src + + + DevDriverComponents\src + + + DevDriverComponents\src + + + DevDriverComponents\src + + + DevDriverComponents\src + + + DevDriverComponents\listener + + + DevDriverComponents\listener + + + DevDriverComponents\listener + + + DevDriverComponents\listener + + + DevDriverComponents\listener + + + DevDriverComponents\listener + + + DevDriverComponents\listener\transports + + + DevDriverComponents\listener\transports + + + DevDriverComponents\listener\transports + + + DevDriverComponents\listener\clientmanagers + + + DevDriverAPI + + + DevDriverAPI + + + DevDriverAPI + + + + + DevDriverComponents\src + + + \ No newline at end of file diff --git a/renderdoc/driver/ihv/amd/official/RGP/ADL/include/adl_defines.h b/renderdoc/driver/ihv/amd/official/RGP/ADL/include/adl_defines.h new file mode 100644 index 000000000..442908b12 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/ADL/include/adl_defines.h @@ -0,0 +1,1526 @@ +// +// Copyright (c) 2008 - 2013 Advanced Micro Devices, Inc. + +// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +// EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +// WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + +/// \file adl_defines.h +/// \brief Contains all definitions exposed by ADL for \ALL platforms.\n Included in ADL SDK +/// +/// This file contains all definitions used by ADL. +/// The ADL definitions include the following: +/// \li ADL error codes +/// \li Enumerations for the ADLDisplayInfo structure +/// \li Maximum limits +/// + +#ifndef ADL_DEFINES_H_ +#define ADL_DEFINES_H_ + +/// \defgroup DEFINES Constants and Definitions +// @{ + +/// \defgroup define_misc Miscellaneous Constant Definitions +// @{ + +/// \name General Definitions +// @{ + +/// Defines ADL_TRUE +#define ADL_TRUE 1 +/// Defines ADL_FALSE +#define ADL_FALSE 0 + +/// Defines the maximum string length +#define ADL_MAX_CHAR 4096 +/// Defines the maximum string length +#define ADL_MAX_PATH 256 +/// Defines the maximum number of supported adapters +#define ADL_MAX_ADAPTERS 250 +/// Defines the maxumum number of supported displays +#define ADL_MAX_DISPLAYS 150 +/// Defines the maxumum string length for device name +#define ADL_MAX_DEVICENAME 32 +/// Defines for all adapters +#define ADL_ADAPTER_INDEX_ALL -1 +/// Defines APIs with iOption none +#define ADL_MAIN_API_OPTION_NONE 0 +// @} + +/// \name Definitions for iOption parameter used by +/// ADL_Display_DDCBlockAccess_Get() +// @{ + +/// Switch to DDC line 2 before sending the command to the display. +#define ADL_DDC_OPTION_SWITCHDDC2 0x00000001 +/// Save command in the registry under a unique key, corresponding to parameter \b iCommandIndex +#define ADL_DDC_OPTION_RESTORECOMMAND 0x00000002 +/// Combine write-read DDC block access command. +#define ADL_DDC_OPTION_COMBOWRITEREAD 0x00000010 +/// Direct DDC access to the immediate device connected to graphics card. +/// MST with this option set: DDC command is sent to first branch. +/// MST with this option not set: DDC command is sent to the end node sink device. +#define ADL_DDC_OPTION_SENDTOIMMEDIATEDEVICE 0x00000020 +// @} + +/// \name Values for +/// ADLI2C.iAction used with ADL_Display_WriteAndReadI2C() +// @{ + +#define ADL_DL_I2C_ACTIONREAD 0x00000001 +#define ADL_DL_I2C_ACTIONWRITE 0x00000002 +#define ADL_DL_I2C_ACTIONREAD_REPEATEDSTART 0x00000003 +// @} + + +// @} //Misc + +/// \defgroup define_adl_results Result Codes +/// This group of definitions are the various results returned by all ADL functions \n +// @{ +/// All OK, but need to wait +#define ADL_OK_WAIT 4 +/// All OK, but need restart +#define ADL_OK_RESTART 3 +/// All OK but need mode change +#define ADL_OK_MODE_CHANGE 2 +/// All OK, but with warning +#define ADL_OK_WARNING 1 +/// ADL function completed successfully +#define ADL_OK 0 +/// Generic Error. Most likely one or more of the Escape calls to the driver failed! +#define ADL_ERR -1 +/// ADL not initialized +#define ADL_ERR_NOT_INIT -2 +/// One of the parameter passed is invalid +#define ADL_ERR_INVALID_PARAM -3 +/// One of the parameter size is invalid +#define ADL_ERR_INVALID_PARAM_SIZE -4 +/// Invalid ADL index passed +#define ADL_ERR_INVALID_ADL_IDX -5 +/// Invalid controller index passed +#define ADL_ERR_INVALID_CONTROLLER_IDX -6 +/// Invalid display index passed +#define ADL_ERR_INVALID_DIPLAY_IDX -7 +/// Function not supported by the driver +#define ADL_ERR_NOT_SUPPORTED -8 +/// Null Pointer error +#define ADL_ERR_NULL_POINTER -9 +/// Call can't be made due to disabled adapter +#define ADL_ERR_DISABLED_ADAPTER -10 +/// Invalid Callback +#define ADL_ERR_INVALID_CALLBACK -11 +/// Display Resource conflict +#define ADL_ERR_RESOURCE_CONFLICT -12 +//Failed to update some of the values. Can be returned by set request that include multiple values if not all values were successfully committed. +#define ADL_ERR_SET_INCOMPLETE -20 + +// @} +/// + +/// \defgroup define_display_type Display Type +/// Define Monitor/CRT display type +// @{ +/// Define Monitor display type +#define ADL_DT_MONITOR 0 +/// Define TV display type +#define ADL_DT_TELEVISION 1 +/// Define LCD display type +#define ADL_DT_LCD_PANEL 2 +/// Define DFP display type +#define ADL_DT_DIGITAL_FLAT_PANEL 3 +/// Define Componment Video display type +#define ADL_DT_COMPONENT_VIDEO 4 +/// Define Projector display type +#define ADL_DT_PROJECTOR 5 +// @} + +/// \defgroup define_display_connection_type Display Connection Type +// @{ +/// Define unknown display output type +#define ADL_DOT_UNKNOWN 0 +/// Define composite display output type +#define ADL_DOT_COMPOSITE 1 +/// Define SVideo display output type +#define ADL_DOT_SVIDEO 2 +/// Define analog display output type +#define ADL_DOT_ANALOG 3 +/// Define digital display output type +#define ADL_DOT_DIGITAL 4 +// @} + +/// \defgroup define_color_type Display Color Type and Source +/// Define Display Color Type and Source +// @{ +#define ADL_DISPLAY_COLOR_BRIGHTNESS (1 << 0) +#define ADL_DISPLAY_COLOR_CONTRAST (1 << 1) +#define ADL_DISPLAY_COLOR_SATURATION (1 << 2) +#define ADL_DISPLAY_COLOR_HUE (1 << 3) +#define ADL_DISPLAY_COLOR_TEMPERATURE (1 << 4) + +/// Color Temperature Source is EDID +#define ADL_DISPLAY_COLOR_TEMPERATURE_SOURCE_EDID (1 << 5) +/// Color Temperature Source is User +#define ADL_DISPLAY_COLOR_TEMPERATURE_SOURCE_USER (1 << 6) +// @} + +/// \defgroup define_adjustment_capabilities Display Adjustment Capabilities +/// Display adjustment capabilities values. Returned by ADL_Display_AdjustCaps_Get +// @{ +#define ADL_DISPLAY_ADJUST_OVERSCAN (1 << 0) +#define ADL_DISPLAY_ADJUST_VERT_POS (1 << 1) +#define ADL_DISPLAY_ADJUST_HOR_POS (1 << 2) +#define ADL_DISPLAY_ADJUST_VERT_SIZE (1 << 3) +#define ADL_DISPLAY_ADJUST_HOR_SIZE (1 << 4) +#define ADL_DISPLAY_ADJUST_SIZEPOS (ADL_DISPLAY_ADJUST_VERT_POS | ADL_DISPLAY_ADJUST_HOR_POS | ADL_DISPLAY_ADJUST_VERT_SIZE | ADL_DISPLAY_ADJUST_HOR_SIZE) +#define ADL_DISPLAY_CUSTOMMODES (1<<5) +#define ADL_DISPLAY_ADJUST_UNDERSCAN (1<<6) +// @} + + +/// \defgroup define_desktop_config Desktop Configuration Flags +/// These flags are used by ADL_DesktopConfig_xxx +/// \deprecated This API has been deprecated because it was only used for RandR 1.1 (Red Hat 5.x) distributions which is now not supported. +// @{ +#define ADL_DESKTOPCONFIG_UNKNOWN 0 /* UNKNOWN desktop config */ +#define ADL_DESKTOPCONFIG_SINGLE (1 << 0) /* Single */ +#define ADL_DESKTOPCONFIG_CLONE (1 << 2) /* Clone */ +#define ADL_DESKTOPCONFIG_BIGDESK_H (1 << 4) /* Big Desktop Horizontal */ +#define ADL_DESKTOPCONFIG_BIGDESK_V (1 << 5) /* Big Desktop Vertical */ +#define ADL_DESKTOPCONFIG_BIGDESK_HR (1 << 6) /* Big Desktop Reverse Horz */ +#define ADL_DESKTOPCONFIG_BIGDESK_VR (1 << 7) /* Big Desktop Reverse Vert */ +#define ADL_DESKTOPCONFIG_RANDR12 (1 << 8) /* RandR 1.2 Multi-display */ +// @} + +/// needed for ADLDDCInfo structure +#define ADL_MAX_DISPLAY_NAME 256 + +/// \defgroup define_edid_flags Values for ulDDCInfoFlag +/// defines for ulDDCInfoFlag EDID flag +// @{ +#define ADL_DISPLAYDDCINFOEX_FLAG_PROJECTORDEVICE (1 << 0) +#define ADL_DISPLAYDDCINFOEX_FLAG_EDIDEXTENSION (1 << 1) +#define ADL_DISPLAYDDCINFOEX_FLAG_DIGITALDEVICE (1 << 2) +#define ADL_DISPLAYDDCINFOEX_FLAG_HDMIAUDIODEVICE (1 << 3) +#define ADL_DISPLAYDDCINFOEX_FLAG_SUPPORTS_AI (1 << 4) +#define ADL_DISPLAYDDCINFOEX_FLAG_SUPPORT_xvYCC601 (1 << 5) +#define ADL_DISPLAYDDCINFOEX_FLAG_SUPPORT_xvYCC709 (1 << 6) +// @} + +/// \defgroup define_displayinfo_connector Display Connector Type +/// defines for ADLDisplayInfo.iDisplayConnector +// @{ +#define ADL_DISPLAY_CONTYPE_UNKNOWN 0 +#define ADL_DISPLAY_CONTYPE_VGA 1 +#define ADL_DISPLAY_CONTYPE_DVI_D 2 +#define ADL_DISPLAY_CONTYPE_DVI_I 3 +#define ADL_DISPLAY_CONTYPE_ATICVDONGLE_NTSC 4 +#define ADL_DISPLAY_CONTYPE_ATICVDONGLE_JPN 5 +#define ADL_DISPLAY_CONTYPE_ATICVDONGLE_NONI2C_JPN 6 +#define ADL_DISPLAY_CONTYPE_ATICVDONGLE_NONI2C_NTSC 7 +#define ADL_DISPLAY_CONTYPE_PROPRIETARY 8 +#define ADL_DISPLAY_CONTYPE_HDMI_TYPE_A 10 +#define ADL_DISPLAY_CONTYPE_HDMI_TYPE_B 11 +#define ADL_DISPLAY_CONTYPE_SVIDEO 12 +#define ADL_DISPLAY_CONTYPE_COMPOSITE 13 +#define ADL_DISPLAY_CONTYPE_RCA_3COMPONENT 14 +#define ADL_DISPLAY_CONTYPE_DISPLAYPORT 15 +#define ADL_DISPLAY_CONTYPE_EDP 16 +#define ADL_DISPLAY_CONTYPE_WIRELESSDISPLAY 17 +// @} + +/// TV Capabilities and Standards +/// \defgroup define_tv_caps TV Capabilities and Standards +/// \deprecated Dropping support for TV displays +// @{ +#define ADL_TV_STANDARDS (1 << 0) +#define ADL_TV_SCART (1 << 1) + +/// TV Standards Definitions +#define ADL_STANDARD_NTSC_M (1 << 0) +#define ADL_STANDARD_NTSC_JPN (1 << 1) +#define ADL_STANDARD_NTSC_N (1 << 2) +#define ADL_STANDARD_PAL_B (1 << 3) +#define ADL_STANDARD_PAL_COMB_N (1 << 4) +#define ADL_STANDARD_PAL_D (1 << 5) +#define ADL_STANDARD_PAL_G (1 << 6) +#define ADL_STANDARD_PAL_H (1 << 7) +#define ADL_STANDARD_PAL_I (1 << 8) +#define ADL_STANDARD_PAL_K (1 << 9) +#define ADL_STANDARD_PAL_K1 (1 << 10) +#define ADL_STANDARD_PAL_L (1 << 11) +#define ADL_STANDARD_PAL_M (1 << 12) +#define ADL_STANDARD_PAL_N (1 << 13) +#define ADL_STANDARD_PAL_SECAM_D (1 << 14) +#define ADL_STANDARD_PAL_SECAM_K (1 << 15) +#define ADL_STANDARD_PAL_SECAM_K1 (1 << 16) +#define ADL_STANDARD_PAL_SECAM_L (1 << 17) +// @} + + +/// \defgroup define_video_custom_mode Video Custom Mode flags +/// Component Video Custom Mode flags. This is used by the iFlags parameter in ADLCustomMode +// @{ +#define ADL_CUSTOMIZEDMODEFLAG_MODESUPPORTED (1 << 0) +#define ADL_CUSTOMIZEDMODEFLAG_NOTDELETETABLE (1 << 1) +#define ADL_CUSTOMIZEDMODEFLAG_INSERTBYDRIVER (1 << 2) +#define ADL_CUSTOMIZEDMODEFLAG_INTERLACED (1 << 3) +#define ADL_CUSTOMIZEDMODEFLAG_BASEMODE (1 << 4) +// @} + +/// \defgroup define_ddcinfoflag Values used for DDCInfoFlag +/// ulDDCInfoFlag field values used by the ADLDDCInfo structure +// @{ +#define ADL_DISPLAYDDCINFOEX_FLAG_PROJECTORDEVICE (1 << 0) +#define ADL_DISPLAYDDCINFOEX_FLAG_EDIDEXTENSION (1 << 1) +#define ADL_DISPLAYDDCINFOEX_FLAG_DIGITALDEVICE (1 << 2) +#define ADL_DISPLAYDDCINFOEX_FLAG_HDMIAUDIODEVICE (1 << 3) +#define ADL_DISPLAYDDCINFOEX_FLAG_SUPPORTS_AI (1 << 4) +#define ADL_DISPLAYDDCINFOEX_FLAG_SUPPORT_xvYCC601 (1 << 5) +#define ADL_DISPLAYDDCINFOEX_FLAG_SUPPORT_xvYCC709 (1 << 6) +// @} + +/// \defgroup define_cv_dongle Values used by ADL_CV_DongleSettings_xxx +/// The following is applicable to ADL_DISPLAY_CONTYPE_ATICVDONGLE_JP and ADL_DISPLAY_CONTYPE_ATICVDONGLE_NONI2C_D only +/// \deprecated Dropping support for Component Video displays +// @{ +#define ADL_DISPLAY_CV_DONGLE_D1 (1 << 0) +#define ADL_DISPLAY_CV_DONGLE_D2 (1 << 1) +#define ADL_DISPLAY_CV_DONGLE_D3 (1 << 2) +#define ADL_DISPLAY_CV_DONGLE_D4 (1 << 3) +#define ADL_DISPLAY_CV_DONGLE_D5 (1 << 4) + +/// The following is applicable to ADL_DISPLAY_CONTYPE_ATICVDONGLE_NA and ADL_DISPLAY_CONTYPE_ATICVDONGLE_NONI2C only + +#define ADL_DISPLAY_CV_DONGLE_480I (1 << 0) +#define ADL_DISPLAY_CV_DONGLE_480P (1 << 1) +#define ADL_DISPLAY_CV_DONGLE_540P (1 << 2) +#define ADL_DISPLAY_CV_DONGLE_720P (1 << 3) +#define ADL_DISPLAY_CV_DONGLE_1080I (1 << 4) +#define ADL_DISPLAY_CV_DONGLE_1080P (1 << 5) +#define ADL_DISPLAY_CV_DONGLE_16_9 (1 << 6) +#define ADL_DISPLAY_CV_DONGLE_720P50 (1 << 7) +#define ADL_DISPLAY_CV_DONGLE_1080I25 (1 << 8) +#define ADL_DISPLAY_CV_DONGLE_576I25 (1 << 9) +#define ADL_DISPLAY_CV_DONGLE_576P50 (1 << 10) +#define ADL_DISPLAY_CV_DONGLE_1080P24 (1 << 11) +#define ADL_DISPLAY_CV_DONGLE_1080P25 (1 << 12) +#define ADL_DISPLAY_CV_DONGLE_1080P30 (1 << 13) +#define ADL_DISPLAY_CV_DONGLE_1080P50 (1 << 14) +// @} + +/// \defgroup define_formats_ovr Formats Override Settings +/// Display force modes flags +// @{ +/// +#define ADL_DISPLAY_FORMAT_FORCE_720P 0x00000001 +#define ADL_DISPLAY_FORMAT_FORCE_1080I 0x00000002 +#define ADL_DISPLAY_FORMAT_FORCE_1080P 0x00000004 +#define ADL_DISPLAY_FORMAT_FORCE_720P50 0x00000008 +#define ADL_DISPLAY_FORMAT_FORCE_1080I25 0x00000010 +#define ADL_DISPLAY_FORMAT_FORCE_576I25 0x00000020 +#define ADL_DISPLAY_FORMAT_FORCE_576P50 0x00000040 +#define ADL_DISPLAY_FORMAT_FORCE_1080P24 0x00000080 +#define ADL_DISPLAY_FORMAT_FORCE_1080P25 0x00000100 +#define ADL_DISPLAY_FORMAT_FORCE_1080P30 0x00000200 +#define ADL_DISPLAY_FORMAT_FORCE_1080P50 0x00000400 + +///< Below are \b EXTENDED display mode flags + +#define ADL_DISPLAY_FORMAT_CVDONGLEOVERIDE 0x00000001 +#define ADL_DISPLAY_FORMAT_CVMODEUNDERSCAN 0x00000002 +#define ADL_DISPLAY_FORMAT_FORCECONNECT_SUPPORTED 0x00000004 +#define ADL_DISPLAY_FORMAT_RESTRICT_FORMAT_SELECTION 0x00000008 +#define ADL_DISPLAY_FORMAT_SETASPECRATIO 0x00000010 +#define ADL_DISPLAY_FORMAT_FORCEMODES 0x00000020 +#define ADL_DISPLAY_FORMAT_LCDRTCCOEFF 0x00000040 +// @} + +/// Defines used by OD5 +#define ADL_PM_PARAM_DONT_CHANGE 0 + +/// The following defines Bus types +// @{ +#define ADL_BUSTYPE_PCI 0 /* PCI bus */ +#define ADL_BUSTYPE_AGP 1 /* AGP bus */ +#define ADL_BUSTYPE_PCIE 2 /* PCI Express bus */ +#define ADL_BUSTYPE_PCIE_GEN2 3 /* PCI Express 2nd generation bus */ +#define ADL_BUSTYPE_PCIE_GEN3 4 /* PCI Express 3rd generation bus */ +// @} + +/// \defgroup define_ws_caps Workstation Capabilities +/// Workstation values +// @{ + +/// This value indicates that the workstation card supports active stereo though stereo output connector +#define ADL_STEREO_SUPPORTED (1 << 2) +/// This value indicates that the workstation card supports active stereo via "blue-line" +#define ADL_STEREO_BLUE_LINE (1 << 3) +/// This value is used to turn off stereo mode. +#define ADL_STEREO_OFF 0 +/// This value indicates that the workstation card supports active stereo. This is also used to set the stereo mode to active though the stereo output connector +#define ADL_STEREO_ACTIVE (1 << 1) +/// This value indicates that the workstation card supports auto-stereo monitors with horizontal interleave. This is also used to set the stereo mode to use the auto-stereo monitor with horizontal interleave +#define ADL_STEREO_AUTO_HORIZONTAL (1 << 30) +/// This value indicates that the workstation card supports auto-stereo monitors with vertical interleave. This is also used to set the stereo mode to use the auto-stereo monitor with vertical interleave +#define ADL_STEREO_AUTO_VERTICAL (1 << 31) +/// This value indicates that the workstation card supports passive stereo, ie. non stereo sync +#define ADL_STEREO_PASSIVE (1 << 6) +/// This value indicates that the workstation card supports auto-stereo monitors with vertical interleave. This is also used to set the stereo mode to use the auto-stereo monitor with vertical interleave +#define ADL_STEREO_PASSIVE_HORIZ (1 << 7) +/// This value indicates that the workstation card supports auto-stereo monitors with vertical interleave. This is also used to set the stereo mode to use the auto-stereo monitor with vertical interleave +#define ADL_STEREO_PASSIVE_VERT (1 << 8) +/// This value indicates that the workstation card supports auto-stereo monitors with Samsung. +#define ADL_STEREO_AUTO_SAMSUNG (1 << 11) +/// This value indicates that the workstation card supports auto-stereo monitors with Tridility. +#define ADL_STEREO_AUTO_TSL (1 << 12) +/// This value indicates that the workstation card supports DeepBitDepth (10 bpp) +#define ADL_DEEPBITDEPTH_10BPP_SUPPORTED (1 << 5) + +/// This value indicates that the workstation supports 8-Bit Grayscale +#define ADL_8BIT_GREYSCALE_SUPPORTED (1 << 9) +/// This value indicates that the workstation supports CUSTOM TIMING +#define ADL_CUSTOM_TIMING_SUPPORTED (1 << 10) + +/// Load balancing is supported. +#define ADL_WORKSTATION_LOADBALANCING_SUPPORTED 0x00000001 +/// Load balancing is available. +#define ADL_WORKSTATION_LOADBALANCING_AVAILABLE 0x00000002 + +/// Load balancing is disabled. +#define ADL_WORKSTATION_LOADBALANCING_DISABLED 0x00000000 +/// Load balancing is Enabled. +#define ADL_WORKSTATION_LOADBALANCING_ENABLED 0x00000001 + + + +// @} + +/// \defgroup define_adapterspeed speed setting from the adapter +// @{ +#define ADL_CONTEXT_SPEED_UNFORCED 0 /* default asic running speed */ +#define ADL_CONTEXT_SPEED_FORCEHIGH 1 /* asic running speed is forced to high */ +#define ADL_CONTEXT_SPEED_FORCELOW 2 /* asic running speed is forced to low */ + +#define ADL_ADAPTER_SPEEDCAPS_SUPPORTED (1 << 0) /* change asic running speed setting is supported */ +// @} + +/// \defgroup define_glsync Genlock related values +/// GL-Sync port types (unique values) +// @{ +/// Unknown port of GL-Sync module +#define ADL_GLSYNC_PORT_UNKNOWN 0 +/// BNC port of of GL-Sync module +#define ADL_GLSYNC_PORT_BNC 1 +/// RJ45(1) port of of GL-Sync module +#define ADL_GLSYNC_PORT_RJ45PORT1 2 +/// RJ45(2) port of of GL-Sync module +#define ADL_GLSYNC_PORT_RJ45PORT2 3 + +// GL-Sync Genlock settings mask (bit-vector) + +/// None of the ADLGLSyncGenlockConfig members are valid +#define ADL_GLSYNC_CONFIGMASK_NONE 0 +/// The ADLGLSyncGenlockConfig.lSignalSource member is valid +#define ADL_GLSYNC_CONFIGMASK_SIGNALSOURCE (1 << 0) +/// The ADLGLSyncGenlockConfig.iSyncField member is valid +#define ADL_GLSYNC_CONFIGMASK_SYNCFIELD (1 << 1) +/// The ADLGLSyncGenlockConfig.iSampleRate member is valid +#define ADL_GLSYNC_CONFIGMASK_SAMPLERATE (1 << 2) +/// The ADLGLSyncGenlockConfig.lSyncDelay member is valid +#define ADL_GLSYNC_CONFIGMASK_SYNCDELAY (1 << 3) +/// The ADLGLSyncGenlockConfig.iTriggerEdge member is valid +#define ADL_GLSYNC_CONFIGMASK_TRIGGEREDGE (1 << 4) +/// The ADLGLSyncGenlockConfig.iScanRateCoeff member is valid +#define ADL_GLSYNC_CONFIGMASK_SCANRATECOEFF (1 << 5) +/// The ADLGLSyncGenlockConfig.lFramelockCntlVector member is valid +#define ADL_GLSYNC_CONFIGMASK_FRAMELOCKCNTL (1 << 6) + + +// GL-Sync Framelock control mask (bit-vector) + +/// Framelock is disabled +#define ADL_GLSYNC_FRAMELOCKCNTL_NONE 0 +/// Framelock is enabled +#define ADL_GLSYNC_FRAMELOCKCNTL_ENABLE ( 1 << 0) + +#define ADL_GLSYNC_FRAMELOCKCNTL_DISABLE ( 1 << 1) +#define ADL_GLSYNC_FRAMELOCKCNTL_SWAP_COUNTER_RESET ( 1 << 2) +#define ADL_GLSYNC_FRAMELOCKCNTL_SWAP_COUNTER_ACK ( 1 << 3) +#define ADL_GLSYNC_FRAMELOCKCNTL_VERSION_KMD (1 << 4) + +#define ADL_GLSYNC_FRAMELOCKCNTL_STATE_ENABLE ( 1 << 0) +#define ADL_GLSYNC_FRAMELOCKCNTL_STATE_KMD (1 << 4) + +// GL-Sync Framelock counters mask (bit-vector) +#define ADL_GLSYNC_COUNTER_SWAP ( 1 << 0 ) + +// GL-Sync Signal Sources (unique values) + +/// GL-Sync signal source is undefined +#define ADL_GLSYNC_SIGNALSOURCE_UNDEFINED 0x00000100 +/// GL-Sync signal source is Free Run +#define ADL_GLSYNC_SIGNALSOURCE_FREERUN 0x00000101 +/// GL-Sync signal source is the BNC GL-Sync port +#define ADL_GLSYNC_SIGNALSOURCE_BNCPORT 0x00000102 +/// GL-Sync signal source is the RJ45(1) GL-Sync port +#define ADL_GLSYNC_SIGNALSOURCE_RJ45PORT1 0x00000103 +/// GL-Sync signal source is the RJ45(2) GL-Sync port +#define ADL_GLSYNC_SIGNALSOURCE_RJ45PORT2 0x00000104 + + +// GL-Sync Signal Types (unique values) + +/// GL-Sync signal type is unknown +#define ADL_GLSYNC_SIGNALTYPE_UNDEFINED 0 +/// GL-Sync signal type is 480I +#define ADL_GLSYNC_SIGNALTYPE_480I 1 +/// GL-Sync signal type is 576I +#define ADL_GLSYNC_SIGNALTYPE_576I 2 +/// GL-Sync signal type is 480P +#define ADL_GLSYNC_SIGNALTYPE_480P 3 +/// GL-Sync signal type is 576P +#define ADL_GLSYNC_SIGNALTYPE_576P 4 +/// GL-Sync signal type is 720P +#define ADL_GLSYNC_SIGNALTYPE_720P 5 +/// GL-Sync signal type is 1080P +#define ADL_GLSYNC_SIGNALTYPE_1080P 6 +/// GL-Sync signal type is 1080I +#define ADL_GLSYNC_SIGNALTYPE_1080I 7 +/// GL-Sync signal type is SDI +#define ADL_GLSYNC_SIGNALTYPE_SDI 8 +/// GL-Sync signal type is TTL +#define ADL_GLSYNC_SIGNALTYPE_TTL 9 +/// GL_Sync signal type is Analog +#define ADL_GLSYNC_SIGNALTYPE_ANALOG 10 + +// GL-Sync Sync Field options (unique values) + +///GL-Sync sync field option is undefined +#define ADL_GLSYNC_SYNCFIELD_UNDEFINED 0 +///GL-Sync sync field option is Sync to Field 1 (used for Interlaced signal types) +#define ADL_GLSYNC_SYNCFIELD_BOTH 1 +///GL-Sync sync field option is Sync to Both fields (used for Interlaced signal types) +#define ADL_GLSYNC_SYNCFIELD_1 2 + + +// GL-Sync trigger edge options (unique values) + +/// GL-Sync trigger edge is undefined +#define ADL_GLSYNC_TRIGGEREDGE_UNDEFINED 0 +/// GL-Sync trigger edge is the rising edge +#define ADL_GLSYNC_TRIGGEREDGE_RISING 1 +/// GL-Sync trigger edge is the falling edge +#define ADL_GLSYNC_TRIGGEREDGE_FALLING 2 +/// GL-Sync trigger edge is both the rising and the falling edge +#define ADL_GLSYNC_TRIGGEREDGE_BOTH 3 + + +// GL-Sync scan rate coefficient/multiplier options (unique values) + +/// GL-Sync scan rate coefficient/multiplier is undefined +#define ADL_GLSYNC_SCANRATECOEFF_UNDEFINED 0 +/// GL-Sync scan rate coefficient/multiplier is 5 +#define ADL_GLSYNC_SCANRATECOEFF_x5 1 +/// GL-Sync scan rate coefficient/multiplier is 4 +#define ADL_GLSYNC_SCANRATECOEFF_x4 2 +/// GL-Sync scan rate coefficient/multiplier is 3 +#define ADL_GLSYNC_SCANRATECOEFF_x3 3 +/// GL-Sync scan rate coefficient/multiplier is 5:2 (SMPTE) +#define ADL_GLSYNC_SCANRATECOEFF_x5_DIV_2 4 +/// GL-Sync scan rate coefficient/multiplier is 2 +#define ADL_GLSYNC_SCANRATECOEFF_x2 5 +/// GL-Sync scan rate coefficient/multiplier is 3 : 2 +#define ADL_GLSYNC_SCANRATECOEFF_x3_DIV_2 6 +/// GL-Sync scan rate coefficient/multiplier is 5 : 4 +#define ADL_GLSYNC_SCANRATECOEFF_x5_DIV_4 7 +/// GL-Sync scan rate coefficient/multiplier is 1 (default) +#define ADL_GLSYNC_SCANRATECOEFF_x1 8 +/// GL-Sync scan rate coefficient/multiplier is 4 : 5 +#define ADL_GLSYNC_SCANRATECOEFF_x4_DIV_5 9 +/// GL-Sync scan rate coefficient/multiplier is 2 : 3 +#define ADL_GLSYNC_SCANRATECOEFF_x2_DIV_3 10 +/// GL-Sync scan rate coefficient/multiplier is 1 : 2 +#define ADL_GLSYNC_SCANRATECOEFF_x1_DIV_2 11 +/// GL-Sync scan rate coefficient/multiplier is 2 : 5 (SMPTE) +#define ADL_GLSYNC_SCANRATECOEFF_x2_DIV_5 12 +/// GL-Sync scan rate coefficient/multiplier is 1 : 3 +#define ADL_GLSYNC_SCANRATECOEFF_x1_DIV_3 13 +/// GL-Sync scan rate coefficient/multiplier is 1 : 4 +#define ADL_GLSYNC_SCANRATECOEFF_x1_DIV_4 14 +/// GL-Sync scan rate coefficient/multiplier is 1 : 5 +#define ADL_GLSYNC_SCANRATECOEFF_x1_DIV_5 15 + + +// GL-Sync port (signal presence) states (unique values) + +/// GL-Sync port state is undefined +#define ADL_GLSYNC_PORTSTATE_UNDEFINED 0 +/// GL-Sync port is not connected +#define ADL_GLSYNC_PORTSTATE_NOCABLE 1 +/// GL-Sync port is Idle +#define ADL_GLSYNC_PORTSTATE_IDLE 2 +/// GL-Sync port has an Input signal +#define ADL_GLSYNC_PORTSTATE_INPUT 3 +/// GL-Sync port is Output +#define ADL_GLSYNC_PORTSTATE_OUTPUT 4 + + +// GL-Sync LED types (used index within ADL_Workstation_GLSyncPortState_Get returned ppGlSyncLEDs array) (unique values) + +/// Index into the ADL_Workstation_GLSyncPortState_Get returned ppGlSyncLEDs array for the one LED of the BNC port +#define ADL_GLSYNC_LEDTYPE_BNC 0 +/// Index into the ADL_Workstation_GLSyncPortState_Get returned ppGlSyncLEDs array for the Left LED of the RJ45(1) or RJ45(2) port +#define ADL_GLSYNC_LEDTYPE_RJ45_LEFT 0 +/// Index into the ADL_Workstation_GLSyncPortState_Get returned ppGlSyncLEDs array for the Right LED of the RJ45(1) or RJ45(2) port +#define ADL_GLSYNC_LEDTYPE_RJ45_RIGHT 1 + + +// GL-Sync LED colors (unique values) + +/// GL-Sync LED undefined color +#define ADL_GLSYNC_LEDCOLOR_UNDEFINED 0 +/// GL-Sync LED is unlit +#define ADL_GLSYNC_LEDCOLOR_NOLIGHT 1 +/// GL-Sync LED is yellow +#define ADL_GLSYNC_LEDCOLOR_YELLOW 2 +/// GL-Sync LED is red +#define ADL_GLSYNC_LEDCOLOR_RED 3 +/// GL-Sync LED is green +#define ADL_GLSYNC_LEDCOLOR_GREEN 4 +/// GL-Sync LED is flashing green +#define ADL_GLSYNC_LEDCOLOR_FLASH_GREEN 5 + + +// GL-Sync Port Control (refers one GL-Sync Port) (unique values) + +/// Used to configure the RJ54(1) or RJ42(2) port of GL-Sync is as Idle +#define ADL_GLSYNC_PORTCNTL_NONE 0x00000000 +/// Used to configure the RJ54(1) or RJ42(2) port of GL-Sync is as Output +#define ADL_GLSYNC_PORTCNTL_OUTPUT 0x00000001 + + +// GL-Sync Mode Control (refers one Display/Controller) (bitfields) + +/// Used to configure the display to use internal timing (not genlocked) +#define ADL_GLSYNC_MODECNTL_NONE 0x00000000 +/// Bitfield used to configure the display as genlocked (either as Timing Client or as Timing Server) +#define ADL_GLSYNC_MODECNTL_GENLOCK 0x00000001 +/// Bitfield used to configure the display as Timing Server +#define ADL_GLSYNC_MODECNTL_TIMINGSERVER 0x00000002 + +// GL-Sync Mode Status +/// Display is currently not genlocked +#define ADL_GLSYNC_MODECNTL_STATUS_NONE 0x00000000 +/// Display is currently genlocked +#define ADL_GLSYNC_MODECNTL_STATUS_GENLOCK 0x00000001 +/// Display requires a mode switch +#define ADL_GLSYNC_MODECNTL_STATUS_SETMODE_REQUIRED 0x00000002 +/// Display is capable of being genlocked +#define ADL_GLSYNC_MODECNTL_STATUS_GENLOCK_ALLOWED 0x00000004 + +#define ADL_MAX_GLSYNC_PORTS 8 +#define ADL_MAX_GLSYNC_PORT_LEDS 8 + +// @} + +/// \defgroup define_crossfirestate CrossfireX state of a particular adapter CrossfireX combination +// @{ +#define ADL_XFIREX_STATE_NOINTERCONNECT ( 1 << 0 ) /* Dongle / cable is missing */ +#define ADL_XFIREX_STATE_DOWNGRADEPIPES ( 1 << 1 ) /* CrossfireX can be enabled if pipes are downgraded */ +#define ADL_XFIREX_STATE_DOWNGRADEMEM ( 1 << 2 ) /* CrossfireX cannot be enabled unless mem downgraded */ +#define ADL_XFIREX_STATE_REVERSERECOMMENDED ( 1 << 3 ) /* Card reversal recommended, CrossfireX cannot be enabled. */ +#define ADL_XFIREX_STATE_3DACTIVE ( 1 << 4 ) /* 3D client is active - CrossfireX cannot be safely enabled */ +#define ADL_XFIREX_STATE_MASTERONSLAVE ( 1 << 5 ) /* Dongle is OK but master is on slave */ +#define ADL_XFIREX_STATE_NODISPLAYCONNECT ( 1 << 6 ) /* No (valid) display connected to master card. */ +#define ADL_XFIREX_STATE_NOPRIMARYVIEW ( 1 << 7 ) /* CrossfireX is enabled but master is not current primary device */ +#define ADL_XFIREX_STATE_DOWNGRADEVISMEM ( 1 << 8 ) /* CrossfireX cannot be enabled unless visible mem downgraded */ +#define ADL_XFIREX_STATE_LESSTHAN8LANE_MASTER ( 1 << 9 ) /* CrossfireX can be enabled however performance not optimal due to <8 lanes */ +#define ADL_XFIREX_STATE_LESSTHAN8LANE_SLAVE ( 1 << 10 ) /* CrossfireX can be enabled however performance not optimal due to <8 lanes */ +#define ADL_XFIREX_STATE_PEERTOPEERFAILED ( 1 << 11 ) /* CrossfireX cannot be enabled due to failed peer to peer test */ +#define ADL_XFIREX_STATE_MEMISDOWNGRADED ( 1 << 16 ) /* Notification that memory is currently downgraded */ +#define ADL_XFIREX_STATE_PIPESDOWNGRADED ( 1 << 17 ) /* Notification that pipes are currently downgraded */ +#define ADL_XFIREX_STATE_XFIREXACTIVE ( 1 << 18 ) /* CrossfireX is enabled on current device */ +#define ADL_XFIREX_STATE_VISMEMISDOWNGRADED ( 1 << 19 ) /* Notification that visible FB memory is currently downgraded */ +#define ADL_XFIREX_STATE_INVALIDINTERCONNECTION ( 1 << 20 ) /* Cannot support current inter-connection configuration */ +#define ADL_XFIREX_STATE_NONP2PMODE ( 1 << 21 ) /* CrossfireX will only work with clients supporting non P2P mode */ +#define ADL_XFIREX_STATE_DOWNGRADEMEMBANKS ( 1 << 22 ) /* CrossfireX cannot be enabled unless memory banks downgraded */ +#define ADL_XFIREX_STATE_MEMBANKSDOWNGRADED ( 1 << 23 ) /* Notification that memory banks are currently downgraded */ +#define ADL_XFIREX_STATE_DUALDISPLAYSALLOWED ( 1 << 24 ) /* Extended desktop or clone mode is allowed. */ +#define ADL_XFIREX_STATE_P2P_APERTURE_MAPPING ( 1 << 25 ) /* P2P mapping was through peer aperture */ +#define ADL_XFIREX_STATE_P2PFLUSH_REQUIRED ADL_XFIREX_STATE_P2P_APERTURE_MAPPING /* For back compatible */ +#define ADL_XFIREX_STATE_XSP_CONNECTED ( 1 << 26 ) /* There is CrossfireX side port connection between GPUs */ +#define ADL_XFIREX_STATE_ENABLE_CF_REBOOT_REQUIRED ( 1 << 27 ) /* System needs a reboot bofore enable CrossfireX */ +#define ADL_XFIREX_STATE_DISABLE_CF_REBOOT_REQUIRED ( 1 << 28 ) /* System needs a reboot after disable CrossfireX */ +#define ADL_XFIREX_STATE_DRV_HANDLE_DOWNGRADE_KEY ( 1 << 29 ) /* Indicate base driver handles the downgrade key updating */ +#define ADL_XFIREX_STATE_CF_RECONFIG_REQUIRED ( 1 << 30 ) /* CrossfireX need to be reconfigured by CCC because of a LDA chain broken */ +#define ADL_XFIREX_STATE_ERRORGETTINGSTATUS ( 1 << 31 ) /* Could not obtain current status */ +// @} + +/////////////////////////////////////////////////////////////////////////// +// ADL_DISPLAY_ADJUSTMENT_PIXELFORMAT adjustment values +// (bit-vector) +/////////////////////////////////////////////////////////////////////////// +/// \defgroup define_pixel_formats Pixel Formats values +/// This group defines the various Pixel Formats that a particular digital display can support. \n +/// Since a display can support multiple formats, these values can be bit-or'ed to indicate the various formats \n +// @{ +#define ADL_DISPLAY_PIXELFORMAT_UNKNOWN 0 +#define ADL_DISPLAY_PIXELFORMAT_RGB (1 << 0) +#define ADL_DISPLAY_PIXELFORMAT_YCRCB444 (1 << 1) //Limited range +#define ADL_DISPLAY_PIXELFORMAT_YCRCB422 (1 << 2) //Limited range +#define ADL_DISPLAY_PIXELFORMAT_RGB_LIMITED_RANGE (1 << 3) +#define ADL_DISPLAY_PIXELFORMAT_RGB_FULL_RANGE ADL_DISPLAY_PIXELFORMAT_RGB //Full range +// @} + +/// \defgroup define_contype Connector Type Values +/// ADLDisplayConfig.ulConnectorType defines +// @{ +#define ADL_DL_DISPLAYCONFIG_CONTYPE_UNKNOWN 0 +#define ADL_DL_DISPLAYCONFIG_CONTYPE_CV_NONI2C_JP 1 +#define ADL_DL_DISPLAYCONFIG_CONTYPE_CV_JPN 2 +#define ADL_DL_DISPLAYCONFIG_CONTYPE_CV_NA 3 +#define ADL_DL_DISPLAYCONFIG_CONTYPE_CV_NONI2C_NA 4 +#define ADL_DL_DISPLAYCONFIG_CONTYPE_VGA 5 +#define ADL_DL_DISPLAYCONFIG_CONTYPE_DVI_D 6 +#define ADL_DL_DISPLAYCONFIG_CONTYPE_DVI_I 7 +#define ADL_DL_DISPLAYCONFIG_CONTYPE_HDMI_TYPE_A 8 +#define ADL_DL_DISPLAYCONFIG_CONTYPE_HDMI_TYPE_B 9 +#define ADL_DL_DISPLAYCONFIG_CONTYPE_DISPLAYPORT 10 +// @} + +/////////////////////////////////////////////////////////////////////////// +// ADL_DISPLAY_DISPLAYINFO_ Definitions +// for ADLDisplayInfo.iDisplayInfoMask and ADLDisplayInfo.iDisplayInfoValue +// (bit-vector) +/////////////////////////////////////////////////////////////////////////// +/// \defgroup define_displayinfomask Display Info Mask Values +// @{ +#define ADL_DISPLAY_DISPLAYINFO_DISPLAYCONNECTED 0x00000001 +#define ADL_DISPLAY_DISPLAYINFO_DISPLAYMAPPED 0x00000002 +#define ADL_DISPLAY_DISPLAYINFO_NONLOCAL 0x00000004 +#define ADL_DISPLAY_DISPLAYINFO_FORCIBLESUPPORTED 0x00000008 +#define ADL_DISPLAY_DISPLAYINFO_GENLOCKSUPPORTED 0x00000010 +#define ADL_DISPLAY_DISPLAYINFO_MULTIVPU_SUPPORTED 0x00000020 +#define ADL_DISPLAY_DISPLAYINFO_LDA_DISPLAY 0x00000040 +#define ADL_DISPLAY_DISPLAYINFO_MODETIMING_OVERRIDESSUPPORTED 0x00000080 + +#define ADL_DISPLAY_DISPLAYINFO_MANNER_SUPPORTED_SINGLE 0x00000100 +#define ADL_DISPLAY_DISPLAYINFO_MANNER_SUPPORTED_CLONE 0x00000200 + +/// Legacy support for XP +#define ADL_DISPLAY_DISPLAYINFO_MANNER_SUPPORTED_2VSTRETCH 0x00000400 +#define ADL_DISPLAY_DISPLAYINFO_MANNER_SUPPORTED_2HSTRETCH 0x00000800 +#define ADL_DISPLAY_DISPLAYINFO_MANNER_SUPPORTED_EXTENDED 0x00001000 + +/// More support manners +#define ADL_DISPLAY_DISPLAYINFO_MANNER_SUPPORTED_NSTRETCH1GPU 0x00010000 +#define ADL_DISPLAY_DISPLAYINFO_MANNER_SUPPORTED_NSTRETCHNGPU 0x00020000 +#define ADL_DISPLAY_DISPLAYINFO_MANNER_SUPPORTED_RESERVED2 0x00040000 +#define ADL_DISPLAY_DISPLAYINFO_MANNER_SUPPORTED_RESERVED3 0x00080000 + +/// Projector display type +#define ADL_DISPLAY_DISPLAYINFO_SHOWTYPE_PROJECTOR 0x00100000 + +// @} + + +/////////////////////////////////////////////////////////////////////////// +// ADL_ADAPTER_DISPLAY_MANNER_SUPPORTED_ Definitions +// for ADLAdapterDisplayCap of ADL_Adapter_Display_Cap() +// (bit-vector) +/////////////////////////////////////////////////////////////////////////// +/// \defgroup define_adaptermanner Adapter Manner Support Values +// @{ +#define ADL_ADAPTER_DISPLAYCAP_MANNER_SUPPORTED_NOTACTIVE 0x00000001 +#define ADL_ADAPTER_DISPLAYCAP_MANNER_SUPPORTED_SINGLE 0x00000002 +#define ADL_ADAPTER_DISPLAYCAP_MANNER_SUPPORTED_CLONE 0x00000004 +#define ADL_ADAPTER_DISPLAYCAP_MANNER_SUPPORTED_NSTRETCH1GPU 0x00000008 +#define ADL_ADAPTER_DISPLAYCAP_MANNER_SUPPORTED_NSTRETCHNGPU 0x00000010 + +/// Legacy support for XP +#define ADL_ADAPTER_DISPLAYCAP_MANNER_SUPPORTED_2VSTRETCH 0x00000020 +#define ADL_ADAPTER_DISPLAYCAP_MANNER_SUPPORTED_2HSTRETCH 0x00000040 +#define ADL_ADAPTER_DISPLAYCAP_MANNER_SUPPORTED_EXTENDED 0x00000080 + +#define ADL_ADAPTER_DISPLAYCAP_PREFERDISPLAY_SUPPORTED 0x00000100 +#define ADL_ADAPTER_DISPLAYCAP_BEZEL_SUPPORTED 0x00000200 + + +/////////////////////////////////////////////////////////////////////////// +// ADL_DISPLAY_DISPLAYMAP_MANNER_ Definitions +// for ADLDisplayMap.iDisplayMapMask and ADLDisplayMap.iDisplayMapValue +// (bit-vector) +/////////////////////////////////////////////////////////////////////////// +#define ADL_DISPLAY_DISPLAYMAP_MANNER_RESERVED 0x00000001 +#define ADL_DISPLAY_DISPLAYMAP_MANNER_NOTACTIVE 0x00000002 +#define ADL_DISPLAY_DISPLAYMAP_MANNER_SINGLE 0x00000004 +#define ADL_DISPLAY_DISPLAYMAP_MANNER_CLONE 0x00000008 +#define ADL_DISPLAY_DISPLAYMAP_MANNER_RESERVED1 0x00000010 // Removed NSTRETCH +#define ADL_DISPLAY_DISPLAYMAP_MANNER_HSTRETCH 0x00000020 +#define ADL_DISPLAY_DISPLAYMAP_MANNER_VSTRETCH 0x00000040 +#define ADL_DISPLAY_DISPLAYMAP_MANNER_VLD 0x00000080 + +// @} + +/////////////////////////////////////////////////////////////////////////// +// ADL_DISPLAY_DISPLAYMAP_OPTION_ Definitions +// for iOption in function ADL_Display_DisplayMapConfig_Get +// (bit-vector) +/////////////////////////////////////////////////////////////////////////// +#define ADL_DISPLAY_DISPLAYMAP_OPTION_GPUINFO 0x00000001 + +/////////////////////////////////////////////////////////////////////////// +// ADL_DISPLAY_DISPLAYTARGET_ Definitions +// for ADLDisplayTarget.iDisplayTargetMask and ADLDisplayTarget.iDisplayTargetValue +// (bit-vector) +/////////////////////////////////////////////////////////////////////////// +#define ADL_DISPLAY_DISPLAYTARGET_PREFERRED 0x00000001 + +/////////////////////////////////////////////////////////////////////////// +// ADL_DISPLAY_POSSIBLEMAPRESULT_VALID Definitions +// for ADLPossibleMapResult.iPossibleMapResultMask and ADLPossibleMapResult.iPossibleMapResultValue +// (bit-vector) +/////////////////////////////////////////////////////////////////////////// +#define ADL_DISPLAY_POSSIBLEMAPRESULT_VALID 0x00000001 +#define ADL_DISPLAY_POSSIBLEMAPRESULT_BEZELSUPPORTED 0x00000002 +#define ADL_DISPLAY_POSSIBLEMAPRESULT_OVERLAPSUPPORTED 0x00000004 + +/////////////////////////////////////////////////////////////////////////// +// ADL_DISPLAY_MODE_ Definitions +// for ADLMode.iModeMask, ADLMode.iModeValue, and ADLMode.iModeFlag +// (bit-vector) +/////////////////////////////////////////////////////////////////////////// +/// \defgroup define_displaymode Display Mode Values +// @{ +#define ADL_DISPLAY_MODE_COLOURFORMAT_565 0x00000001 +#define ADL_DISPLAY_MODE_COLOURFORMAT_8888 0x00000002 +#define ADL_DISPLAY_MODE_ORIENTATION_SUPPORTED_000 0x00000004 +#define ADL_DISPLAY_MODE_ORIENTATION_SUPPORTED_090 0x00000008 +#define ADL_DISPLAY_MODE_ORIENTATION_SUPPORTED_180 0x00000010 +#define ADL_DISPLAY_MODE_ORIENTATION_SUPPORTED_270 0x00000020 +#define ADL_DISPLAY_MODE_REFRESHRATE_ROUNDED 0x00000040 +#define ADL_DISPLAY_MODE_REFRESHRATE_ONLY 0x00000080 + +#define ADL_DISPLAY_MODE_PROGRESSIVE_FLAG 0 +#define ADL_DISPLAY_MODE_INTERLACED_FLAG 2 +// @} + +/////////////////////////////////////////////////////////////////////////// +// ADL_OSMODEINFO Definitions +/////////////////////////////////////////////////////////////////////////// +/// \defgroup define_osmode OS Mode Values +// @{ +#define ADL_OSMODEINFOXPOS_DEFAULT -640 +#define ADL_OSMODEINFOYPOS_DEFAULT 0 +#define ADL_OSMODEINFOXRES_DEFAULT 640 +#define ADL_OSMODEINFOYRES_DEFAULT 480 +#define ADL_OSMODEINFOXRES_DEFAULT800 800 +#define ADL_OSMODEINFOYRES_DEFAULT600 600 +#define ADL_OSMODEINFOREFRESHRATE_DEFAULT 60 +#define ADL_OSMODEINFOCOLOURDEPTH_DEFAULT 8 +#define ADL_OSMODEINFOCOLOURDEPTH_DEFAULT16 16 +#define ADL_OSMODEINFOCOLOURDEPTH_DEFAULT24 24 +#define ADL_OSMODEINFOCOLOURDEPTH_DEFAULT32 32 +#define ADL_OSMODEINFOORIENTATION_DEFAULT 0 +#define ADL_OSMODEINFOORIENTATION_DEFAULT_WIN7 DISPLAYCONFIG_ROTATION_FORCE_UINT32 +#define ADL_OSMODEFLAG_DEFAULT 0 +// @} + + +/////////////////////////////////////////////////////////////////////////// +// ADLThreadingModel Enumeration +/////////////////////////////////////////////////////////////////////////// +/// \defgroup thread_model +/// Used with \ref ADL_Main_ControlX2_Create and \ref ADL2_Main_ControlX2_Create to specify how ADL handles API calls when executed by multiple threads concurrently. +/// \brief Declares ADL threading behavior. +// @{ +typedef enum ADLThreadingModel +{ + ADL_THREADING_UNLOCKED = 0, /*!< Default behavior. ADL will not enforce serialization of ADL API executions by multiple threads. Multiple threads will be allowed to enter to ADL at the same time. Note that ADL library is not guaranteed to be thread-safe. Client that calls ADL_Main_Control_Create have to provide its own mechanism for ADL calls serialization. */ + ADL_THREADING_LOCKED /*!< ADL will enforce serialization of ADL API when called by multiple threads. Only single thread will be allowed to enter ADL API at the time. This option makes ADL calls thread-safe. You shouldn't use this option if ADL calls will be executed on Linux on x-server rendering thread. It can cause the application to hung. */ +}ADLThreadingModel; + +// @} +/////////////////////////////////////////////////////////////////////////// +// ADLPurposeCode Enumeration +/////////////////////////////////////////////////////////////////////////// +enum ADLPurposeCode +{ + ADL_PURPOSECODE_NORMAL = 0, + ADL_PURPOSECODE_HIDE_MODE_SWITCH, + ADL_PURPOSECODE_MODE_SWITCH, + ADL_PURPOSECODE_ATTATCH_DEVICE, + ADL_PURPOSECODE_DETACH_DEVICE, + ADL_PURPOSECODE_SETPRIMARY_DEVICE, + ADL_PURPOSECODE_GDI_ROTATION, + ADL_PURPOSECODE_ATI_ROTATION +}; +/////////////////////////////////////////////////////////////////////////// +// ADLAngle Enumeration +/////////////////////////////////////////////////////////////////////////// +enum ADLAngle +{ + ADL_ANGLE_LANDSCAPE = 0, + ADL_ANGLE_ROTATERIGHT = 90, + ADL_ANGLE_ROTATE180 = 180, + ADL_ANGLE_ROTATELEFT = 270, +}; + +/////////////////////////////////////////////////////////////////////////// +// ADLOrientationDataType Enumeration +/////////////////////////////////////////////////////////////////////////// +enum ADLOrientationDataType +{ + ADL_ORIENTATIONTYPE_OSDATATYPE, + ADL_ORIENTATIONTYPE_NONOSDATATYPE +}; + +/////////////////////////////////////////////////////////////////////////// +// ADLPanningMode Enumeration +/////////////////////////////////////////////////////////////////////////// +enum ADLPanningMode +{ + ADL_PANNINGMODE_NO_PANNING = 0, + ADL_PANNINGMODE_AT_LEAST_ONE_NO_PANNING = 1, + ADL_PANNINGMODE_ALLOW_PANNING = 2, +}; + +/////////////////////////////////////////////////////////////////////////// +// ADLLARGEDESKTOPTYPE Enumeration +/////////////////////////////////////////////////////////////////////////// +enum ADLLARGEDESKTOPTYPE +{ + ADL_LARGEDESKTOPTYPE_NORMALDESKTOP = 0, + ADL_LARGEDESKTOPTYPE_PSEUDOLARGEDESKTOP = 1, + ADL_LARGEDESKTOPTYPE_VERYLARGEDESKTOP = 2 +}; + +/////////////////////////////////////////////////////////////////////////// +// ADLPlatform Enumeration +/////////////////////////////////////////////////////////////////////////// +enum ADLPlatForm +{ + GRAPHICS_PLATFORM_DESKTOP = 0, + GRAPHICS_PLATFORM_MOBILE = 1 +}; +// Other Definitions for internal use + +// Values for ADL_Display_WriteAndReadI2CRev_Get() + +#define ADL_I2C_MAJOR_API_REV 0x00000001 +#define ADL_I2C_MINOR_DEFAULT_API_REV 0x00000000 +#define ADL_I2C_MINOR_OEM_API_REV 0x00000001 + +// Values for ADL_Display_WriteAndReadI2C() +#define ADL_DL_I2C_LINE_OEM 0x00000001 +#define ADL_DL_I2C_LINE_OD_CONTROL 0x00000002 +#define ADL_DL_I2C_LINE_OEM2 0x00000003 +#define ADL_DL_I2C_LINE_OEM3 0x00000004 +#define ADL_DL_I2C_LINE_OEM4 0x00000005 +#define ADL_DL_I2C_LINE_OEM5 0x00000006 +#define ADL_DL_I2C_LINE_OEM6 0x00000007 + +// Max size of I2C data buffer +#define ADL_DL_I2C_MAXDATASIZE 0x00000040 +#define ADL_DL_I2C_MAXWRITEDATASIZE 0x0000000C +#define ADL_DL_I2C_MAXADDRESSLENGTH 0x00000006 +#define ADL_DL_I2C_MAXOFFSETLENGTH 0x00000004 + + +/// Values for ADLDisplayProperty.iPropertyType +#define ADL_DL_DISPLAYPROPERTY_TYPE_UNKNOWN 0 +#define ADL_DL_DISPLAYPROPERTY_TYPE_EXPANSIONMODE 1 +#define ADL_DL_DISPLAYPROPERTY_TYPE_USEUNDERSCANSCALING 2 +/// Enables ITC processing for HDMI panels that are capable of the feature +#define ADL_DL_DISPLAYPROPERTY_TYPE_ITCFLAGENABLE 9 + + +/// Values for ADLDisplayContent.iContentType +/// Certain HDMI panels that support ITC have support for a feature such that, the display on the panel +/// can be adjusted to optimize the view of the content being displayed, depending on the type of content. +#define ADL_DL_DISPLAYCONTENT_TYPE_GRAPHICS 1 +#define ADL_DL_DISPLAYCONTENT_TYPE_PHOTO 2 +#define ADL_DL_DISPLAYCONTENT_TYPE_CINEMA 4 +#define ADL_DL_DISPLAYCONTENT_TYPE_GAME 8 + + + + + +//values for ADLDisplayProperty.iExpansionMode +#define ADL_DL_DISPLAYPROPERTY_EXPANSIONMODE_CENTER 0 +#define ADL_DL_DISPLAYPROPERTY_EXPANSIONMODE_FULLSCREEN 1 +#define ADL_DL_DISPLAYPROPERTY_EXPANSIONMODE_ASPECTRATIO 2 + +//values for ADL_Display_DitherState_Get +#define ADL_DL_DISPLAY_DITHER_UNKNOWN 0 +#define ADL_DL_DISPLAY_DITHER_DISABLED 1 +#define ADL_DL_DISPLAY_DITHER_ENABLED 2 + +/// Display Get Cached EDID flag +#define ADL_MAX_EDIDDATA_SIZE 256 // number of UCHAR +#define ADL_MAX_OVERRIDEEDID_SIZE 512 // number of UCHAR +#define ADL_MAX_EDID_EXTENSION_BLOCKS 3 + +#define ADL_DL_CONTROLLER_OVERLAY_ALPHA 0 +#define ADL_DL_CONTROLLER_OVERLAY_ALPHAPERPIX 1 + +#define ADL_DL_DISPLAY_DATA_PACKET__INFO_PACKET_RESET 0x00000000 +#define ADL_DL_DISPLAY_DATA_PACKET__INFO_PACKET_SET 0x00000001 +#define ADL_DL_DISPLAY_DATA_PACKET__INFO_PACKET_SCAN 0x00000002 + +///\defgroup define_display_packet Display Data Packet Types +// @{ +#define ADL_DL_DISPLAY_DATA_PACKET__TYPE__AVI 0x00000001 +#define ADL_DL_DISPLAY_DATA_PACKET__TYPE__RESERVED 0x00000002 +#define ADL_DL_DISPLAY_DATA_PACKET__TYPE__VENDORINFO 0x00000004 +// @} + +// matrix types +#define ADL_GAMUT_MATRIX_SD 1 // SD matrix i.e. BT601 +#define ADL_GAMUT_MATRIX_HD 2 // HD matrix i.e. BT709 + +///\defgroup define_clockinfo_flags Clock flags +/// Used by ADLAdapterODClockInfo.iFlag +// @{ +#define ADL_DL_CLOCKINFO_FLAG_FULLSCREEN3DONLY 0x00000001 +#define ADL_DL_CLOCKINFO_FLAG_ALWAYSFULLSCREEN3D 0x00000002 +#define ADL_DL_CLOCKINFO_FLAG_VPURECOVERYREDUCED 0x00000004 +#define ADL_DL_CLOCKINFO_FLAG_THERMALPROTECTION 0x00000008 +// @} + +// Supported GPUs +// ADL_Display_PowerXpressActiveGPU_Get() +#define ADL_DL_POWERXPRESS_GPU_INTEGRATED 1 +#define ADL_DL_POWERXPRESS_GPU_DISCRETE 2 + +// Possible values for lpOperationResult +// ADL_Display_PowerXpressActiveGPU_Get() +#define ADL_DL_POWERXPRESS_SWITCH_RESULT_STARTED 1 // Switch procedure has been started - Windows platform only +#define ADL_DL_POWERXPRESS_SWITCH_RESULT_DECLINED 2 // Switch procedure cannot be started - All platforms +#define ADL_DL_POWERXPRESS_SWITCH_RESULT_ALREADY 3 // System already has required status - All platforms +#define ADL_DL_POWERXPRESS_SWITCH_RESULT_DEFERRED 5 // Switch was deferred and requires an X restart - Linux platform only + +// PowerXpress support version +// ADL_Display_PowerXpressVersion_Get() +#define ADL_DL_POWERXPRESS_VERSION_MAJOR 2 // Current PowerXpress support version 2.0 +#define ADL_DL_POWERXPRESS_VERSION_MINOR 0 + +#define ADL_DL_POWERXPRESS_VERSION (((ADL_DL_POWERXPRESS_VERSION_MAJOR) << 16) | ADL_DL_POWERXPRESS_VERSION_MINOR) + +//values for ADLThermalControllerInfo.iThermalControllerDomain +#define ADL_DL_THERMAL_DOMAIN_OTHER 0 +#define ADL_DL_THERMAL_DOMAIN_GPU 1 + +//values for ADLThermalControllerInfo.iFlags +#define ADL_DL_THERMAL_FLAG_INTERRUPT 1 +#define ADL_DL_THERMAL_FLAG_FANCONTROL 2 + +///\defgroup define_fanctrl Fan speed cotrol +/// Values for ADLFanSpeedInfo.iFlags +// @{ +#define ADL_DL_FANCTRL_SUPPORTS_PERCENT_READ 1 +#define ADL_DL_FANCTRL_SUPPORTS_PERCENT_WRITE 2 +#define ADL_DL_FANCTRL_SUPPORTS_RPM_READ 4 +#define ADL_DL_FANCTRL_SUPPORTS_RPM_WRITE 8 +// @} + +//values for ADLFanSpeedValue.iSpeedType +#define ADL_DL_FANCTRL_SPEED_TYPE_PERCENT 1 +#define ADL_DL_FANCTRL_SPEED_TYPE_RPM 2 + +//values for ADLFanSpeedValue.iFlags +#define ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED 1 + +// MVPU interfaces +#define ADL_DL_MAX_MVPU_ADAPTERS 4 +#define MVPU_ADAPTER_0 0x00000001 +#define MVPU_ADAPTER_1 0x00000002 +#define MVPU_ADAPTER_2 0x00000004 +#define MVPU_ADAPTER_3 0x00000008 +#define ADL_DL_MAX_REGISTRY_PATH 256 + +//values for ADLMVPUStatus.iStatus +#define ADL_DL_MVPU_STATUS_OFF 0 +#define ADL_DL_MVPU_STATUS_ON 1 + +// values for ASIC family +///\defgroup define_Asic_type Detailed asic types +/// Defines for Adapter ASIC family type +// @{ +#define ADL_ASIC_UNDEFINED 0 +#define ADL_ASIC_DISCRETE (1 << 0) +#define ADL_ASIC_INTEGRATED (1 << 1) +#define ADL_ASIC_FIREGL (1 << 2) +#define ADL_ASIC_FIREMV (1 << 3) +#define ADL_ASIC_XGP (1 << 4) +#define ADL_ASIC_FUSION (1 << 5) +#define ADL_ASIC_FIRESTREAM (1 << 6) +// @} + +///\defgroup define_detailed_timing_flags Detailed Timimg Flags +/// Defines for ADLDetailedTiming.sTimingFlags field +// @{ +#define ADL_DL_TIMINGFLAG_DOUBLE_SCAN 0x0001 +//sTimingFlags is set when the mode is INTERLACED, if not PROGRESSIVE +#define ADL_DL_TIMINGFLAG_INTERLACED 0x0002 +//sTimingFlags is set when the Horizontal Sync is POSITIVE, if not NEGATIVE +#define ADL_DL_TIMINGFLAG_H_SYNC_POLARITY 0x0004 +//sTimingFlags is set when the Vertical Sync is POSITIVE, if not NEGATIVE +#define ADL_DL_TIMINGFLAG_V_SYNC_POLARITY 0x0008 +// @} + +///\defgroup define_modetiming_standard Timing Standards +/// Defines for ADLDisplayModeInfo.iTimingStandard field +// @{ +#define ADL_DL_MODETIMING_STANDARD_CVT 0x00000001 // CVT Standard +#define ADL_DL_MODETIMING_STANDARD_GTF 0x00000002 // GFT Standard +#define ADL_DL_MODETIMING_STANDARD_DMT 0x00000004 // DMT Standard +#define ADL_DL_MODETIMING_STANDARD_CUSTOM 0x00000008 // User-defined standard +#define ADL_DL_MODETIMING_STANDARD_DRIVER_DEFAULT 0x00000010 // Remove Mode from overriden list +#define ADL_DL_MODETIMING_STANDARD_CVT_RB 0x00000020 // CVT-RB Standard +// @} + +// \defgroup define_xserverinfo driver x-server info +/// These flags are used by ADL_XServerInfo_Get() +// @ + +/// Xinerama is active in the x-server, Xinerama extension may report it to be active but it +/// may not be active in x-server +#define ADL_XSERVERINFO_XINERAMAACTIVE (1<<0) + +/// RandR 1.2 is supported by driver, RandR extension may report version 1.2 +/// but driver may not support it +#define ADL_XSERVERINFO_RANDR12SUPPORTED (1<<1) +// @ + + +///\defgroup define_eyefinity_constants Eyefinity Definitions +// @{ + +#define ADL_CONTROLLERVECTOR_0 1 // ADL_CONTROLLERINDEX_0 = 0, (1 << ADL_CONTROLLERINDEX_0) +#define ADL_CONTROLLERVECTOR_1 2 // ADL_CONTROLLERINDEX_1 = 1, (1 << ADL_CONTROLLERINDEX_1) + +#define ADL_DISPLAY_SLSGRID_ORIENTATION_000 0x00000001 +#define ADL_DISPLAY_SLSGRID_ORIENTATION_090 0x00000002 +#define ADL_DISPLAY_SLSGRID_ORIENTATION_180 0x00000004 +#define ADL_DISPLAY_SLSGRID_ORIENTATION_270 0x00000008 +#define ADL_DISPLAY_SLSGRID_CAP_OPTION_RELATIVETO_LANDSCAPE 0x00000001 +#define ADL_DISPLAY_SLSGRID_CAP_OPTION_RELATIVETO_CURRENTANGLE 0x00000002 +#define ADL_DISPLAY_SLSGRID_PORTAIT_MODE 0x00000004 + + +#define ADL_DISPLAY_SLSMAPCONFIG_GET_OPTION_RELATIVETO_LANDSCAPE 0x00000001 +#define ADL_DISPLAY_SLSMAPCONFIG_GET_OPTION_RELATIVETO_CURRENTANGLE 0x00000002 + +#define ADL_DISPLAY_SLSMAPCONFIG_CREATE_OPTION_RELATIVETO_LANDSCAPE 0x00000001 +#define ADL_DISPLAY_SLSMAPCONFIG_CREATE_OPTION_RELATIVETO_CURRENTANGLE 0x00000002 + +#define ADL_DISPLAY_SLSMAPCONFIG_REARRANGE_OPTION_RELATIVETO_LANDSCAPE 0x00000001 +#define ADL_DISPLAY_SLSMAPCONFIG_REARRANGE_OPTION_RELATIVETO_CURRENTANGLE 0x00000002 + + +#define ADL_DISPLAY_SLSGRID_RELATIVETO_LANDSCAPE 0x00000010 +#define ADL_DISPLAY_SLSGRID_RELATIVETO_CURRENTANGLE 0x00000020 + + +/// The bit mask identifies displays is currently in bezel mode. +#define ADL_DISPLAY_SLSMAP_BEZELMODE 0x00000010 +/// The bit mask identifies displays from this map is arranged. +#define ADL_DISPLAY_SLSMAP_DISPLAYARRANGED 0x00000002 +/// The bit mask identifies this map is currently in used for the current adapter. +#define ADL_DISPLAY_SLSMAP_CURRENTCONFIG 0x00000004 + + ///For onlay active SLS map info +#define ADL_DISPLAY_SLSMAPINDEXLIST_OPTION_ACTIVE 0x00000001 + +///For Bezel +#define ADL_DISPLAY_BEZELOFFSET_STEPBYSTEPSET 0x00000004 +#define ADL_DISPLAY_BEZELOFFSET_COMMIT 0x00000008 + +// @} + +///\defgroup define_powerxpress_constants PowerXpress Definitions +// @{ + +/// The bit mask identifies PX caps for ADLPXConfigCaps.iPXConfigCapMask and ADLPXConfigCaps.iPXConfigCapValue +#define ADL_PX_CONFIGCAPS_SPLASHSCREEN_SUPPORT 0x0001 +#define ADL_PX_CONFIGCAPS_CF_SUPPORT 0x0002 +#define ADL_PX_CONFIGCAPS_MUXLESS 0x0004 +#define ADL_PX_CONFIGCAPS_PROFILE_COMPLIANT 0x0008 +#define ADL_PX_CONFIGCAPS_NON_AMD_DRIVEN_DISPLAYS 0x0010 +#define ADL_PX_CONFIGCAPS_FIXED_SUPPORT 0x0020 +#define ADL_PX_CONFIGCAPS_DYNAMIC_SUPPORT 0x0040 +#define ADL_PX_CONFIGCAPS_HIDE_AUTO_SWITCH 0x0080 + +/// The bit mask identifies PX schemes for ADLPXSchemeRange +#define ADL_PX_SCHEMEMASK_FIXED 0x0001 +#define ADL_PX_SCHEMEMASK_DYNAMIC 0x0002 + +/// PX Schemes +typedef enum _ADLPXScheme +{ + ADL_PX_SCHEME_INVALID = 0, + ADL_PX_SCHEME_FIXED = ADL_PX_SCHEMEMASK_FIXED, + ADL_PX_SCHEME_DYNAMIC = ADL_PX_SCHEMEMASK_DYNAMIC +}ADLPXScheme; + +/// Just keep the old definitions for compatibility, need to be removed later +typedef enum PXScheme +{ + PX_SCHEME_INVALID = 0, + PX_SCHEME_FIXED = 1, + PX_SCHEME_DYNAMIC = 2 +} PXScheme; + + +// @} + +///\defgroup define_appprofiles For Application Profiles +// @{ + +#define ADL_APP_PROFILE_FILENAME_LENGTH 64 +#define ADL_APP_PROFILE_TIMESTAMP_LENGTH 32 +#define ADL_APP_PROFILE_VERSION_LENGTH 32 +#define ADL_APP_PROFILE_PROPERTY_LENGTH 64 + +enum ApplicationListType +{ + ADL_PX40_MRU, + ADL_PX40_MISSED, + ADL_PX40_DISCRETE, + ADL_PX40_INTEGRATED, + + ADL_PX40_TOTAL +}; + +typedef enum _ADLProfilePropertyType +{ + ADL_PROFILEPROPERTY_TYPE_BINARY = 0, + ADL_PROFILEPROPERTY_TYPE_BOOLEAN, + ADL_PROFILEPROPERTY_TYPE_DWORD, + ADL_PROFILEPROPERTY_TYPE_QWORD, + ADL_PROFILEPROPERTY_TYPE_ENUMERATED, + ADL_PROFILEPROPERTY_TYPE_STRING +}ADLProfilePropertyType; + + +// @} + +///\defgroup define_dp12 For Display Port 1.2 +// @{ + +/// Maximum Relative Address Link +#define ADL_MAX_RAD_LINK_COUNT 15 + +// @} + +///\defgroup defines_gamutspace Driver Supported Gamut Space +// @{ + +/// The flags desribes that gamut is related to source or to destination and to overlay or to graphics +#define ADL_GAMUT_REFERENCE_SOURCE (1 << 0) +#define ADL_GAMUT_GAMUT_VIDEO_CONTENT (1 << 1) + +/// The flags are used to describe the source of gamut and how read information from struct ADLGamutData +#define ADL_CUSTOM_WHITE_POINT (1 << 0) +#define ADL_CUSTOM_GAMUT (1 << 1) + +/// The define means the predefined gamut values . +///Driver uses to find entry in the table and apply appropriate gamut space. +#define ADL_GAMUT_SPACE_CCIR_709 (1 << 0) +#define ADL_GAMUT_SPACE_CCIR_601 (1 << 1) +#define ADL_GAMUT_SPACE_ADOBE_RGB (1 << 2) +#define ADL_GAMUT_SPACE_CIE_RGB (1 << 3) +#define ADL_GAMUT_SPACE_CUSTOM (1 << 4) + +/// Predefine white point values are structed similar to gamut . +#define ADL_WHITE_POINT_5000K (1 << 0) +#define ADL_WHITE_POINT_6500K (1 << 1) +#define ADL_WHITE_POINT_7500K (1 << 2) +#define ADL_WHITE_POINT_9300K (1 << 3) +#define ADL_WHITE_POINT_CUSTOM (1 << 4) + +///gamut and white point coordinates are from 0.0 -1.0 and divider is used to find the real value . +/// X float = X int /divider +#define ADL_GAMUT_WHITEPOINT_DIVIDER 10000 + +///gamma a0 coefficient uses the following divider: +#define ADL_REGAMMA_COEFFICIENT_A0_DIVIDER 10000000 +///gamma a1 ,a2,a3 coefficients use the following divider: +#define ADL_REGAMMA_COEFFICIENT_A1A2A3_DIVIDER 1000 + +///describes whether the coefficients are from EDID or custom user values. +#define ADL_EDID_REGAMMA_COEFFICIENTS (1 << 0) +///Used for struct ADLRegamma. Feature if set use gamma ramp, if missing use regamma coefficents +#define ADL_USE_GAMMA_RAMP (1 << 4) +///Used for struct ADLRegamma. If the gamma ramp flag is used then the driver could apply de gamma corretion to the supplied curve and this depends on this flag +#define ADL_APPLY_DEGAMMA (1 << 5) + +// @} + +/// \defgroup define_ddcinfo_pixelformats DDCInfo Pixel Formats +// @{ +/// defines for iPanelPixelFormat in struct ADLDDCInfo2 +#define ADL_DISPLAY_DDCINFO_PIXEL_FORMAT_RGB656 0x00000001L +#define ADL_DISPLAY_DDCINFO_PIXEL_FORMAT_RGB666 0x00000002L +#define ADL_DISPLAY_DDCINFO_PIXEL_FORMAT_RGB888 0x00000004L +#define ADL_DISPLAY_DDCINFO_PIXEL_FORMAT_RGB101010 0x00000008L +#define ADL_DISPLAY_DDCINFO_PIXEL_FORMAT_RGB161616 0x00000010L +#define ADL_DISPLAY_DDCINFO_PIXEL_FORMAT_RGB_RESERVED1 0x00000020L +#define ADL_DISPLAY_DDCINFO_PIXEL_FORMAT_RGB_RESERVED2 0x00000040L +#define ADL_DISPLAY_DDCINFO_PIXEL_FORMAT_RGB_RESERVED3 0x00000080L +#define ADL_DISPLAY_DDCINFO_PIXEL_FORMAT_XRGB_BIAS101010 0x00000100L +#define ADL_DISPLAY_DDCINFO_PIXEL_FORMAT_YCBCR444_8BPCC 0x00000200L +#define ADL_DISPLAY_DDCINFO_PIXEL_FORMAT_YCBCR444_10BPCC 0x00000400L +#define ADL_DISPLAY_DDCINFO_PIXEL_FORMAT_YCBCR444_12BPCC 0x00000800L +#define ADL_DISPLAY_DDCINFO_PIXEL_FORMAT_YCBCR422_8BPCC 0x00001000L +#define ADL_DISPLAY_DDCINFO_PIXEL_FORMAT_YCBCR422_10BPCC 0x00002000L +#define ADL_DISPLAY_DDCINFO_PIXEL_FORMAT_YCBCR422_12BPCC 0x00004000L +// @} + + + +/// \defgroup define_dbd_state Deep Bit Depth +// @{ + +/// defines for ADL_Workstation_DeepBitDepth_Get and ADL_Workstation_DeepBitDepth_Set functions +// This value indicates that the deep bit depth state is forced off +#define ADL_DEEPBITDEPTH_FORCEOFF 0 +/// This value indicates that the deep bit depth state is set to auto, the driver will automatically enable the +/// appropriate deep bit depth state depending on what connected display supports. +#define ADL_DEEPBITDEPTH_10BPP_AUTO 1 +/// This value indicates that the deep bit depth state is forced on to 10 bits per pixel, this is regardless if the display +/// supports 10 bpp. +#define ADL_DEEPBITDEPTH_10BPP_FORCEON 2 + +/// defines for ADLAdapterConfigMemory of ADL_Adapter_ConfigMemory_Get +/// If this bit is set, it indicates that the Deep Bit Depth pixel is set on the display +#define ADL_ADAPTER_CONFIGMEMORY_DBD (1 << 0) +/// If this bit is set, it indicates that the display is rotated (90, 180 or 270) +#define ADL_ADAPTER_CONFIGMEMORY_ROTATE (1 << 1) +/// If this bit is set, it indicates that passive stereo is set on the display +#define ADL_ADAPTER_CONFIGMEMORY_STEREO_PASSIVE (1 << 2) +/// If this bit is set, it indicates that the active stereo is set on the display +#define ADL_ADAPTER_CONFIGMEMORY_STEREO_ACTIVE (1 << 3) +/// If this bit is set, it indicates that the tear free vsync is set on the display +#define ADL_ADAPTER_CONFIGMEMORY_ENHANCEDVSYNC (1 << 4) +#define ADL_ADAPTER_CONFIGMEMORY_TEARFREEVSYNC (1 << 4) +/// @} + +/// \defgroup define_adl_validmemoryrequiredfields Memory Type +/// @{ + +/// This group defines memory types in ADLMemoryRequired struct \n +/// Indicates that this is the visible memory +#define ADL_MEMORYREQTYPE_VISIBLE (1 << 0) +/// Indicates that this is the invisible memory. +#define ADL_MEMORYREQTYPE_INVISIBLE (1 << 1) +/// Indicates that this is amount of visible memory per GPU that should be reserved for all other allocations. +#define ADL_MEMORYREQTYPE_GPURESERVEDVISIBLE (1 << 2) +/// @} + +/// \defgroup define_adapter_tear_free_status +/// Used in ADL_Adapter_TEAR_FREE_Set and ADL_Adapter_TFD_Get functions to indicate the tear free +/// desktop status. +/// @{ +/// Tear free desktop is enabled. +#define ADL_ADAPTER_TEAR_FREE_ON 1 +/// Tear free desktop can't be enabled due to a lack of graphic adapter memory. +#define ADL_ADAPTER_TEAR_FREE_NOTENOUGHMEM -1 +/// Tear free desktop can't be enabled due to quad buffer stereo being enabled. +#define ADL_ADAPTER_TEAR_FREE_OFF_ERR_QUADBUFFERSTEREO -2 +/// Tear free desktop can't be enabled due to MGPU-SLS being enabled. +#define ADL_ADAPTER_TEAR_FREE_OFF_ERR_MGPUSLD -3 +/// Tear free desktop is disabled. +#define ADL_ADAPTER_TEAR_FREE_OFF 0 +/// @} + +/// \defgroup define_adapter_crossdisplay_platforminfo +/// Used in ADL_Adapter_CrossDisplayPlatformInfo_Get function to indicate the Crossdisplay platform info. +/// @{ +/// CROSSDISPLAY platform. +#define ADL_CROSSDISPLAY_PLATFORM (1 << 0) +/// CROSSDISPLAY platform for Lasso station. +#define ADL_CROSSDISPLAY_PLATFORM_LASSO (1 << 1) +/// CROSSDISPLAY platform for docking station. +#define ADL_CROSSDISPLAY_PLATFORM_DOCKSTATION (1 << 2) +/// @} + +/// \defgroup define_adapter_crossdisplay_option +/// Used in ADL_Adapter_CrossdisplayInfoX2_Set function to indicate cross display options. +/// @{ +/// Checking if 3D application is runnning. If yes, not to do switch, return ADL_OK_WAIT; otherwise do switch. +#define ADL_CROSSDISPLAY_OPTION_NONE 0 +/// Force switching without checking for running 3D applications +#define ADL_CROSSDISPLAY_OPTION_FORCESWITCH (1 << 0) +/// @} + +/// \defgroup define_adapter_states Adapter Capabilities +/// These defines the capabilities supported by an adapter. It is used by \ref ADL_Adapter_ConfigureState_Get +/// @{ +/// Indicates that the adapter is headless (i.e. no displays can be connected to it) +#define ADL_ADAPTERCONFIGSTATE_HEADLESS ( 1 << 2 ) +/// Indicates that the adapter is configured to define the main rendering capabilities. For example, adapters +/// in Crossfire(TM) configuration, this bit would only be set on the adapter driving the display(s). +#define ADL_ADAPTERCONFIGSTATE_REQUISITE_RENDER ( 1 << 0 ) +/// Indicates that the adapter is configured to be used to unload some of the rendering work for a particular +/// requisite rendering adapter. For eample, for adapters in a Crossfire configuration, this bit would be set +/// on all adapters that are currently not driving the display(s) +#define ADL_ADAPTERCONFIGSTATE_ANCILLARY_RENDER ( 1 << 1 ) +/// @} + +/// \defgroup define_controllermode_ulModifiers +/// These defines the detailed actions supported by set viewport. It is used by \ref ADL_Display_ViewPort_Set +/// @{ +/// Indicate that the viewport set will change the view position +#define ADL_CONTROLLERMODE_CM_MODIFIER_VIEW_POSITION 0x00000001 +/// Indicate that the viewport set will change the view PanLock +#define ADL_CONTROLLERMODE_CM_MODIFIER_VIEW_PANLOCK 0x00000002 +/// Indicate that the viewport set will change the view size +#define ADL_CONTROLLERMODE_CM_MODIFIER_VIEW_SIZE 0x00000008 +/// @} + +/// \defgroup defines for Mirabilis +/// These defines are used for the Mirabilis feature +/// @{ +/// +/// Indicates the maximum number of audio sample rates +#define ADL_MAX_AUDIO_SAMPLE_RATE_COUNT 16 +/// @} + +/////////////////////////////////////////////////////////////////////////// +// ADLMultiChannelSplitStateFlag Enumeration +/////////////////////////////////////////////////////////////////////////// +enum ADLMultiChannelSplitStateFlag +{ + ADLMultiChannelSplit_Unitialized = 0, + ADLMultiChannelSplit_Disabled = 1, + ADLMultiChannelSplit_Enabled = 2, + ADLMultiChannelSplit_SaveProfile = 3 +}; + +/////////////////////////////////////////////////////////////////////////// +// ADLSampleRate Enumeration +/////////////////////////////////////////////////////////////////////////// +enum ADLSampleRate +{ + ADLSampleRate_32KHz =0, + ADLSampleRate_44P1KHz, + ADLSampleRate_48KHz, + ADLSampleRate_88P2KHz, + ADLSampleRate_96KHz, + ADLSampleRate_176P4KHz, + ADLSampleRate_192KHz, + ADLSampleRate_384KHz, //DP1.2 + ADLSampleRate_768KHz, //DP1.2 + ADLSampleRate_Undefined +}; + +/// \defgroup define_overdrive6_capabilities +/// These defines the capabilities supported by Overdrive 6. It is used by \ref ADL_Overdrive6_Capabilities_Get +// @{ +/// Indicate that core (engine) clock can be changed. +#define ADL_OD6_CAPABILITY_SCLK_CUSTOMIZATION 0x00000001 +/// Indicate that memory clock can be changed. +#define ADL_OD6_CAPABILITY_MCLK_CUSTOMIZATION 0x00000002 +/// Indicate that graphics activity reporting is supported. +#define ADL_OD6_CAPABILITY_GPU_ACTIVITY_MONITOR 0x00000004 +/// Indicate that power limit can be customized. +#define ADL_OD6_CAPABILITY_POWER_CONTROL 0x00000008 +/// Indicate that SVI2 Voltage Control is supported. +#define ADL_OD6_CAPABILITY_VOLTAGE_CONTROL 0x00000010 +/// Indicate that OD6+ percentage adjustment is supported. +#define ADL_OD6_CAPABILITY_PERCENT_ADJUSTMENT 0x00000020 +/// Indicate that Thermal Limit Unlock is supported. +#define ADL_OD6_CAPABILITY_THERMAL_LIMIT_UNLOCK 0x00000040 +// @} + +/// \defgroup define_overdrive6_supported_states +/// These defines the power states supported by Overdrive 6. It is used by \ref ADL_Overdrive6_Capabilities_Get +// @{ +/// Indicate that overdrive is supported in the performance state. This is currently the only state supported. +#define ADL_OD6_SUPPORTEDSTATE_PERFORMANCE 0x00000001 +/// Do not use. Reserved for future use. +#define ADL_OD6_SUPPORTEDSTATE_POWER_SAVING 0x00000002 +// @} + +/// \defgroup define_overdrive6_getstateinfo +/// These defines the power states to get information about. It is used by \ref ADL_Overdrive6_StateInfo_Get +// @{ +/// Get default clocks for the performance state. +#define ADL_OD6_GETSTATEINFO_DEFAULT_PERFORMANCE 0x00000001 +/// Do not use. Reserved for future use. +#define ADL_OD6_GETSTATEINFO_DEFAULT_POWER_SAVING 0x00000002 +/// Get clocks for current state. Currently this is the same as \ref ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE +/// since only performance state is supported. +#define ADL_OD6_GETSTATEINFO_CURRENT 0x00000003 +/// Get the modified clocks (if any) for the performance state. If clocks were not modified +/// through Overdrive 6, then this will return the same clocks as \ref ADL_OD6_GETSTATEINFO_DEFAULT_PERFORMANCE. +#define ADL_OD6_GETSTATEINFO_CUSTOM_PERFORMANCE 0x00000004 +/// Do not use. Reserved for future use. +#define ADL_OD6_GETSTATEINFO_CUSTOM_POWER_SAVING 0x00000005 +// @} + +/// \defgroup define_overdrive6_getstate and define_overdrive6_getmaxclockadjust +/// These defines the power states to get information about. It is used by \ref ADL_Overdrive6_StateEx_Get and \ref ADL_Overdrive6_MaxClockAdjust_Get +// @{ +/// Get default clocks for the performance state. Only performance state is currently supported. +#define ADL_OD6_STATE_PERFORMANCE 0x00000001 +// @} + +/// \defgroup define_overdrive6_setstate +/// These define which power state to set customized clocks on. It is used by \ref ADL_Overdrive6_State_Set +// @{ +/// Set customized clocks for the performance state. +#define ADL_OD6_SETSTATE_PERFORMANCE 0x00000001 +/// Do not use. Reserved for future use. +#define ADL_OD6_SETSTATE_POWER_SAVING 0x00000002 +// @} + +/// \defgroup define_overdrive6_thermalcontroller_caps +/// These defines the capabilities of the GPU thermal controller. It is used by \ref ADL_Overdrive6_ThermalController_Caps +// @{ +/// GPU thermal controller is supported. +#define ADL_OD6_TCCAPS_THERMAL_CONTROLLER 0x00000001 +/// GPU fan speed control is supported. +#define ADL_OD6_TCCAPS_FANSPEED_CONTROL 0x00000002 +/// Fan speed percentage can be read. +#define ADL_OD6_TCCAPS_FANSPEED_PERCENT_READ 0x00000100 +/// Fan speed can be set by specifying a percentage value. +#define ADL_OD6_TCCAPS_FANSPEED_PERCENT_WRITE 0x00000200 +/// Fan speed RPM (revolutions-per-minute) can be read. +#define ADL_OD6_TCCAPS_FANSPEED_RPM_READ 0x00000400 +/// Fan speed can be set by specifying an RPM value. +#define ADL_OD6_TCCAPS_FANSPEED_RPM_WRITE 0x00000800 +// @} + +/// \defgroup define_overdrive6_fanspeed_type +/// These defines the fan speed type being reported. It is used by \ref ADL_Overdrive6_FanSpeed_Get +// @{ +/// Fan speed reported in percentage. +#define ADL_OD6_FANSPEED_TYPE_PERCENT 0x00000001 +/// Fan speed reported in RPM. +#define ADL_OD6_FANSPEED_TYPE_RPM 0x00000002 +/// Fan speed has been customized by the user, and fan is not running in automatic mode. +#define ADL_OD6_FANSPEED_USER_DEFINED 0x00000100 +// @} + +/// \defgroup define_ecc_mode_states +/// These defines the ECC(Error Correction Code) state. It is used by \ref ADL_Workstation_ECC_Get,ADL_Workstation_ECC_Set +// @{ +/// Error Correction is disabled. +#define ECC_MODE_OFF 0 +/// Error Correction is enabled. +#define ECC_MODE_ON 2 +// @} + +// End Bracket for Constants and Definitions. Add new groups ABOVE this line! + +// @} + +#endif /* ADL_DEFINES_H_ */ + + diff --git a/renderdoc/driver/ihv/amd/official/RGP/ADL/include/adl_sdk.h b/renderdoc/driver/ihv/amd/official/RGP/ADL/include/adl_sdk.h new file mode 100644 index 000000000..c0ad27e17 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/ADL/include/adl_sdk.h @@ -0,0 +1,29 @@ +/// +/// Copyright (c) 2008 - 2013 Advanced Micro Devices, Inc. + +/// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +/// EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +/// WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + +/// \file adl_sdk.h +/// \brief Contains the definition of the Memory Allocation Callback.\n Included in ADL SDK +/// +/// \n\n +/// This file contains the definition of the Memory Allocation Callback.\n +/// It also includes definitions of the respective structures and constants.\n +/// This is the only header file to be included in a C/C++ project using ADL + +#ifndef ADL_SDK_H_ +#define ADL_SDK_H_ + +#include "adl_structures.h" + +#if defined (LINUX) +#define __stdcall +#endif /* (LINUX) */ + +/// Memory Allocation Call back +typedef void* ( __stdcall *ADL_MAIN_MALLOC_CALLBACK )( int ); + + +#endif /* ADL_SDK_H_ */ diff --git a/renderdoc/driver/ihv/amd/official/RGP/ADL/include/adl_structures.h b/renderdoc/driver/ihv/amd/official/RGP/ADL/include/adl_structures.h new file mode 100644 index 000000000..1bfb57950 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/ADL/include/adl_structures.h @@ -0,0 +1,2143 @@ +/// +/// Copyright (c) 2008 - 2013 Advanced Micro Devices, Inc. + +/// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +/// EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED +/// WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR PURPOSE. + +/// \file adl_structures.h +///\brief This file contains the structure declarations that are used by the public ADL interfaces for \ALL platforms.\n Included in ADL SDK +/// +/// All data structures used in AMD Display Library (ADL) public interfaces should be defined in this header file. +/// + +#ifndef ADL_STRUCTURES_H_ +#define ADL_STRUCTURES_H_ + +#include "adl_defines.h" + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about the graphics adapter. +/// +/// This structure is used to store various information about the graphics adapter. This +/// information can be returned to the user. Alternatively, it can be used to access various driver calls to set +/// or fetch various settings upon the user's request. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct AdapterInfo +{ +/// \ALL_STRUCT_MEM + +/// Size of the structure. + int iSize; +/// The ADL index handle. One GPU may be associated with one or two index handles + int iAdapterIndex; +/// The unique device ID associated with this adapter. + char strUDID[ADL_MAX_PATH]; +/// The BUS number associated with this adapter. + int iBusNumber; +/// The driver number associated with this adapter. + int iDeviceNumber; +/// The function number. + int iFunctionNumber; +/// The vendor ID associated with this adapter. + int iVendorID; +/// Adapter name. + char strAdapterName[ADL_MAX_PATH]; +/// Display name. For example, "\\Display0" for Windows or ":0:0" for Linux. + char strDisplayName[ADL_MAX_PATH]; +/// Present or not; 1 if present and 0 if not present.It the logical adapter is present, the display name such as \\.\Display1 can be found from OS + int iPresent; +// @} + +#if defined (_WIN32) || defined (_WIN64) +/// \WIN_STRUCT_MEM + +/// Exist or not; 1 is exist and 0 is not present. + int iExist; +/// Driver registry path. + char strDriverPath[ADL_MAX_PATH]; +/// Driver registry path Ext for. + char strDriverPathExt[ADL_MAX_PATH]; +/// PNP string from Windows. + char strPNPString[ADL_MAX_PATH]; +/// It is generated from EnumDisplayDevices. + int iOSDisplayIndex; +// @} +#endif /* (_WIN32) || (_WIN64) */ + +#if defined (LINUX) +/// \LNX_STRUCT_MEM + +/// Internal X screen number from GPUMapInfo (DEPRICATED use XScreenInfo) + int iXScreenNum; +/// Internal driver index from GPUMapInfo + int iDrvIndex; +/// \deprecated Internal x config file screen identifier name. Use XScreenInfo instead. + char strXScreenConfigName[ADL_MAX_PATH]; + +// @} +#endif /* (LINUX) */ +} AdapterInfo, *LPAdapterInfo; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about the Linux X screen information. +/// +/// This structure is used to store the current screen number and xorg.conf ID name assoicated with an adapter index. +/// This structure is updated during ADL_Main_Control_Refresh or ADL_ScreenInfo_Update. +/// Note: This structure should be used in place of iXScreenNum and strXScreenConfigName in AdapterInfo as they will be +/// deprecated. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +#if defined (LINUX) +typedef struct XScreenInfo +{ +/// Internal X screen number from GPUMapInfo. + int iXScreenNum; +/// Internal x config file screen identifier name. + char strXScreenConfigName[ADL_MAX_PATH]; +} XScreenInfo, *LPXScreenInfo; +#endif /* (LINUX) */ + + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about the ASIC memory. +/// +/// This structure is used to store various information about the ASIC memory. This +/// information can be returned to the user. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLMemoryInfo +{ +/// Memory size in bytes. + long long iMemorySize; +/// Memory type in string. + char strMemoryType[ADL_MAX_PATH]; +/// Memory bandwidth in Mbytes/s. + long long iMemoryBandwidth; +} ADLMemoryInfo, *LPADLMemoryInfo; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about memory required by type +/// +/// This structure is returned by ADL_Adapter_ConfigMemory_Get, which given a desktop and display configuration +/// will return the Memory used. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLMemoryRequired +{ + long long iMemoryReq; /// Memory in bytes required + int iType; /// Type of Memory \ref define_adl_validmemoryrequiredfields + int iDisplayFeatureValue; /// Display features \ref define_adl_visiblememoryfeatures that are using this type of memory +} ADLMemoryRequired, *LPADLMemoryRequired; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about the features associated with a display +/// +/// This structure is a parameter to ADL_Adapter_ConfigMemory_Get, which given a desktop and display configuration +/// will return the Memory used. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLMemoryDisplayFeatures +{ + int iDisplayIndex; /// ADL Display index + int iDisplayFeatureValue; /// features that the display is using \ref define_adl_visiblememoryfeatures +} ADLMemoryDisplayFeatures, *LPADLMemoryDisplayFeatures; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing DDC information. +/// +/// This structure is used to store various DDC information that can be returned to the user. +/// Note that all fields of type int are actually defined as unsigned int types within the driver. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLDDCInfo +{ +/// Size of the structure + int ulSize; +/// Indicates whether the attached display supports DDC. If this field is zero on return, no other DDC information fields will be used. + int ulSupportsDDC; +/// Returns the manufacturer ID of the display device. Should be zeroed if this information is not available. + int ulManufacturerID; +/// Returns the product ID of the display device. Should be zeroed if this information is not available. + int ulProductID; +/// Returns the name of the display device. Should be zeroed if this information is not available. + char cDisplayName[ADL_MAX_DISPLAY_NAME]; +/// Returns the maximum Horizontal supported resolution. Should be zeroed if this information is not available. + int ulMaxHResolution; +/// Returns the maximum Vertical supported resolution. Should be zeroed if this information is not available. + int ulMaxVResolution; +/// Returns the maximum supported refresh rate. Should be zeroed if this information is not available. + int ulMaxRefresh; +/// Returns the display device preferred timing mode's horizontal resolution. + int ulPTMCx; +/// Returns the display device preferred timing mode's vertical resolution. + int ulPTMCy; +/// Returns the display device preferred timing mode's refresh rate. + int ulPTMRefreshRate; +/// Return EDID flags. + int ulDDCInfoFlag; +} ADLDDCInfo, *LPADLDDCInfo; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing DDC information. +/// +/// This structure is used to store various DDC information that can be returned to the user. +/// Note that all fields of type int are actually defined as unsigned int types within the driver. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLDDCInfo2 +{ +/// Size of the structure + int ulSize; +/// Indicates whether the attached display supports DDC. If this field is zero on return, no other DDC +/// information fields will be used. + int ulSupportsDDC; +/// Returns the manufacturer ID of the display device. Should be zeroed if this information is not available. + int ulManufacturerID; +/// Returns the product ID of the display device. Should be zeroed if this information is not available. + int ulProductID; +/// Returns the name of the display device. Should be zeroed if this information is not available. + char cDisplayName[ADL_MAX_DISPLAY_NAME]; +/// Returns the maximum Horizontal supported resolution. Should be zeroed if this information is not available. + int ulMaxHResolution; +/// Returns the maximum Vertical supported resolution. Should be zeroed if this information is not available. + int ulMaxVResolution; +/// Returns the maximum supported refresh rate. Should be zeroed if this information is not available. + int ulMaxRefresh; +/// Returns the display device preferred timing mode's horizontal resolution. + int ulPTMCx; +/// Returns the display device preferred timing mode's vertical resolution. + int ulPTMCy; +/// Returns the display device preferred timing mode's refresh rate. + int ulPTMRefreshRate; +/// Return EDID flags. + int ulDDCInfoFlag; +// Returns 1 if the display supported packed pixel, 0 otherwise + int bPackedPixelSupported; +// Returns the Pixel formats the display supports \ref define_ddcinfo_pixelformats + int iPanelPixelFormat; +/// Return EDID serial ID. + int ulSerialID; +// Reserved for future use + int iReserved[26]; +} ADLDDCInfo2, *LPADLDDCInfo2; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information controller Gamma settings. +/// +/// This structure is used to store the red, green and blue color channel information for the. +/// controller gamma setting. This information is returned by ADL, and it can also be used to +/// set the controller gamma setting. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLGamma +{ +/// Red color channel gamma value. + float fRed; +/// Green color channel gamma value. + float fGreen; +/// Blue color channel gamma value. + float fBlue; +} ADLGamma, *LPADLGamma; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about component video custom modes. +/// +/// This structure is used to store the component video custom mode. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLCustomMode +{ +/// Custom mode flags. They are returned by the ADL driver. + int iFlags; +/// Custom mode width. + int iModeWidth; +/// Custom mode height. + int iModeHeight; +/// Custom mode base width. + int iBaseModeWidth; +/// Custom mode base height. + int iBaseModeHeight; +/// Custom mode refresh rate. + int iRefreshRate; +} ADLCustomMode, *LPADLCustomMode; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing Clock information for OD5 calls. +/// +/// This structure is used to retrieve clock information for OD5 calls. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLGetClocksOUT +{ + long ulHighCoreClock; + long ulHighMemoryClock; + long ulHighVddc; + long ulCoreMin; + long ulCoreMax; + long ulMemoryMin; + long ulMemoryMax; + long ulActivityPercent; + long ulCurrentCoreClock; + long ulCurrentMemoryClock; + long ulReserved; +} ADLGetClocksOUT; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing HDTV information for display calls. +/// +/// This structure is used to retrieve HDTV information information for display calls. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLDisplayConfig +{ +/// Size of the structure + long ulSize; +/// HDTV connector type. + long ulConnectorType; +/// HDTV capabilities. + long ulDeviceData; +/// Overridden HDTV capabilities. + long ulOverridedDeviceData; +/// Reserved field + long ulReserved; +} ADLDisplayConfig; + + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about the display device. +/// +/// This structure is used to store display device information +/// such as display index, type, name, connection status, mapped adapter and controller indexes, +/// whether or not multiple VPUs are supported, local display connections or not (through Lasso), etc. +/// This information can be returned to the user. Alternatively, it can be used to access various driver calls to set +/// or fetch various display device related settings upon the user's request. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLDisplayID +{ +/// The logical display index belonging to this adapter. + int iDisplayLogicalIndex; + +///\brief The physical display index. +/// For example, display index 2 from adapter 2 can be used by current adapter 1.\n +/// So current adapter may enumerate this adapter as logical display 7 but the physical display +/// index is still 2. + int iDisplayPhysicalIndex; + +/// The persistent logical adapter index for the display. + int iDisplayLogicalAdapterIndex; + +///\brief The persistent physical adapter index for the display. +/// It can be the current adapter or a non-local adapter. \n +/// If this adapter index is different than the current adapter, +/// the Display Non Local flag is set inside DisplayInfoValue. + int iDisplayPhysicalAdapterIndex; +} ADLDisplayID, *LPADLDisplayID; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about the display device. +/// +/// This structure is used to store various information about the display device. This +/// information can be returned to the user, or used to access various driver calls to set +/// or fetch various display-device-related settings upon the user's request +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLDisplayInfo +{ +/// The DisplayID structure + ADLDisplayID displayID; + +///\deprecated The controller index to which the display is mapped.\n Will not be used in the future\n + int iDisplayControllerIndex; + +/// The display's EDID name. + char strDisplayName[ADL_MAX_PATH]; + +/// The display's manufacturer name. + char strDisplayManufacturerName[ADL_MAX_PATH]; + +/// The Display type. For example: CRT, TV, CV, DFP. + int iDisplayType; + +/// The display output type. For example: HDMI, SVIDEO, COMPONMNET VIDEO. + int iDisplayOutputType; + +/// The connector type for the device. + int iDisplayConnector; + +///\brief The bit mask identifies the number of bits ADLDisplayInfo is currently using. \n +/// It will be the sum all the bit definitions in ADL_DISPLAY_DISPLAYINFO_xxx. + int iDisplayInfoMask; + +/// The bit mask identifies the display status. \ref define_displayinfomask + int iDisplayInfoValue; +} ADLDisplayInfo, *LPADLDisplayInfo; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about the display port MST device. +/// +/// This structure is used to store various MST information about the display port device. This +/// information can be returned to the user, or used to access various driver calls to +/// fetch various display-device-related settings upon the user's request +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLDisplayDPMSTInfo +{ + /// The ADLDisplayID structure + ADLDisplayID displayID; + + /// total bandwidth available on the DP connector + int iTotalAvailableBandwidthInMpbs; + /// bandwidth allocated to this display + int iAllocatedBandwidthInMbps; + + // info from DAL DpMstSinkInfo + /// string identifier for the display + char strGlobalUniqueIdentifier[ADL_MAX_PATH]; + + /// The link count of relative address, rad[0] upto rad[linkCount] are valid + int radLinkCount; + /// The physical connector ID, used to identify the physical DP port + int iPhysicalConnectorID; + + /// Relative address, address scheme starts from source side + char rad[ADL_MAX_RAD_LINK_COUNT]; +} ADLDisplayDPMSTInfo, *LPADLDisplayDPMSTInfo; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing the display mode definition used per controller. +/// +/// This structure is used to store the display mode definition used per controller. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLDisplayMode +{ +/// Vertical resolution (in pixels). + int iPelsHeight; +/// Horizontal resolution (in pixels). + int iPelsWidth; +/// Color depth. + int iBitsPerPel; +/// Refresh rate. + int iDisplayFrequency; +} ADLDisplayMode; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing detailed timing parameters. +/// +/// This structure is used to store the detailed timing parameters. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLDetailedTiming +{ +/// Size of the structure. + int iSize; +/// Timing flags. \ref define_detailed_timing_flags + short sTimingFlags; +/// Total width (columns). + short sHTotal; +/// Displayed width. + short sHDisplay; +/// Horizontal sync signal offset. + short sHSyncStart; +/// Horizontal sync signal width. + short sHSyncWidth; +/// Total height (rows). + short sVTotal; +/// Displayed height. + short sVDisplay; +/// Vertical sync signal offset. + short sVSyncStart; +/// Vertical sync signal width. + short sVSyncWidth; +/// Pixel clock value. + short sPixelClock; +/// Overscan right. + short sHOverscanRight; +/// Overscan left. + short sHOverscanLeft; +/// Overscan bottom. + short sVOverscanBottom; +/// Overscan top. + short sVOverscanTop; + short sOverscan8B; + short sOverscanGR; +} ADLDetailedTiming; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing display mode information. +/// +/// This structure is used to store the display mode information. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLDisplayModeInfo +{ +/// Timing standard of the current mode. \ref define_modetiming_standard + int iTimingStandard; +/// Applicable timing standards for the current mode. + int iPossibleStandard; +/// Refresh rate factor. + int iRefreshRate; +/// Num of pixels in a row. + int iPelsWidth; +/// Num of pixels in a column. + int iPelsHeight; +/// Detailed timing parameters. + ADLDetailedTiming sDetailedTiming; +} ADLDisplayModeInfo; + +///////////////////////////////////////////////////////////////////////////////////////////// +/// \brief Structure containing information about display property. +/// +/// This structure is used to store the display property for the current adapter. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLDisplayProperty +{ +/// Must be set to sizeof the structure + int iSize; +/// Must be set to \ref ADL_DL_DISPLAYPROPERTY_TYPE_EXPANSIONMODE or \ref ADL_DL_DISPLAYPROPERTY_TYPE_USEUNDERSCANSCALING + int iPropertyType; +/// Get or Set \ref ADL_DL_DISPLAYPROPERTY_EXPANSIONMODE_CENTER or \ref ADL_DL_DISPLAYPROPERTY_EXPANSIONMODE_FULLSCREEN or \ref ADL_DL_DISPLAYPROPERTY_EXPANSIONMODE_ASPECTRATIO or \ref ADL_DL_DISPLAYPROPERTY_TYPE_ITCFLAGENABLE + int iExpansionMode; +/// Display Property supported? 1: Supported, 0: Not supported + int iSupport; +/// Display Property current value + int iCurrent; +/// Display Property Default value + int iDefault; +} ADLDisplayProperty; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about Clock. +/// +/// This structure is used to store the clock information for the current adapter +/// such as core clock and memory clock info. +///\nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLClockInfo +{ +/// Core clock in 10 KHz. + int iCoreClock; +/// Memory clock in 10 KHz. + int iMemoryClock; +} ADLClockInfo, *LPADLClockInfo; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about I2C. +/// +/// This structure is used to store the I2C information for the current adapter. +/// This structure is used by the ADL_Display_WriteAndReadI2C() function. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLI2C +{ +/// Size of the structure + int iSize; +/// Numerical value representing hardware I2C. + int iLine; +/// The 7-bit I2C slave device address, shifted one bit to the left. + int iAddress; +/// The offset of the data from the address. + int iOffset; +/// Read from or write to slave device. \ref ADL_DL_I2C_ACTIONREAD or \ref ADL_DL_I2C_ACTIONWRITE or \ref ADL_DL_I2C_ACTIONREAD_REPEATEDSTART + int iAction; +/// I2C clock speed in KHz. + int iSpeed; +/// A numerical value representing the number of bytes to be sent or received on the I2C bus. + int iDataSize; +/// Address of the characters which are to be sent or received on the I2C bus. + char *pcData; +} ADLI2C; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about EDID data. +/// +/// This structure is used to store the information about EDID data for the adapter. +/// This structure is used by the ADL_Display_EdidData_Get() and ADL_Display_EdidData_Set() functions. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLDisplayEDIDData +{ +/// Size of the structure + int iSize; +/// Set to 0 + int iFlag; + /// Size of cEDIDData. Set by ADL_Display_EdidData_Get() upon return + int iEDIDSize; +/// 0, 1 or 2. If set to 3 or above an error ADL_ERR_INVALID_PARAM is generated + int iBlockIndex; +/// EDID data + char cEDIDData[ADL_MAX_EDIDDATA_SIZE]; +/// Reserved + int iReserved[4]; +}ADLDisplayEDIDData; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about input of controller overlay adjustment. +/// +/// This structure is used to store the information about input of controller overlay adjustment for the adapter. +/// This structure is used by the ADL_Display_ControllerOverlayAdjustmentCaps_Get, ADL_Display_ControllerOverlayAdjustmentData_Get, and +/// ADL_Display_ControllerOverlayAdjustmentData_Set() functions. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLControllerOverlayInput +{ +/// Should be set to the sizeof the structure + int iSize; +///\ref ADL_DL_CONTROLLER_OVERLAY_ALPHA or \ref ADL_DL_CONTROLLER_OVERLAY_ALPHAPERPIX + int iOverlayAdjust; +/// Data. + int iValue; +/// Should be 0. + int iReserved; +} ADLControllerOverlayInput; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about overlay adjustment. +/// +/// This structure is used to store the information about overlay adjustment for the adapter. +/// This structure is used by the ADLControllerOverlayInfo() function. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLAdjustmentinfo +{ +/// Default value + int iDefault; +/// Minimum value + int iMin; +/// Maximum Value + int iMax; +/// Step value + int iStep; +} ADLAdjustmentinfo; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about controller overlay information. +/// +/// This structure is used to store information about controller overlay info for the adapter. +/// This structure is used by the ADL_Display_ControllerOverlayAdjustmentCaps_Get() function. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLControllerOverlayInfo +{ +/// Should be set to the sizeof the structure + int iSize; +/// Data. + ADLAdjustmentinfo sOverlayInfo; +/// Should be 0. + int iReserved[3]; +} ADLControllerOverlayInfo; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing GL-Sync module information. +/// +/// This structure is used to retrieve GL-Sync module information for +/// Workstation Framelock/Genlock. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLGLSyncModuleID +{ +/// Unique GL-Sync module ID. + int iModuleID; +/// GL-Sync GPU port index (to be passed into ADLGLSyncGenlockConfig.lSignalSource and ADLGlSyncPortControl.lSignalSource). + int iGlSyncGPUPort; +/// GL-Sync module firmware version of Boot Sector. + int iFWBootSectorVersion; +/// GL-Sync module firmware version of User Sector. + int iFWUserSectorVersion; +} ADLGLSyncModuleID , *LPADLGLSyncModuleID; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing GL-Sync ports capabilities. +/// +/// This structure is used to retrieve hardware capabilities for the ports of the GL-Sync module +/// for Workstation Framelock/Genlock (such as port type and number of associated LEDs). +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLGLSyncPortCaps +{ +/// Port type. Bitfield of ADL_GLSYNC_PORTTYPE_* \ref define_glsync + int iPortType; +/// Number of LEDs associated for this port. + int iNumOfLEDs; +}ADLGLSyncPortCaps, *LPADLGLSyncPortCaps; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing GL-Sync Genlock settings. +/// +/// This structure is used to get and set genlock settings for the GPU ports of the GL-Sync module +/// for Workstation Framelock/Genlock.\n +/// \see define_glsync +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLGLSyncGenlockConfig +{ +/// Specifies what fields in this structure are valid \ref define_glsync + int iValidMask; +/// Delay (ms) generating a sync signal. + int iSyncDelay; +/// Vector of framelock control bits. Bitfield of ADL_GLSYNC_FRAMELOCKCNTL_* \ref define_glsync + int iFramelockCntlVector; +/// Source of the sync signal. Either GL_Sync GPU Port index or ADL_GLSYNC_SIGNALSOURCE_* \ref define_glsync + int iSignalSource; +/// Use sampled sync signal. A value of 0 specifies no sampling. + int iSampleRate; +/// For interlaced sync signals, the value can be ADL_GLSYNC_SYNCFIELD_1 or *_BOTH \ref define_glsync + int iSyncField; +/// The signal edge that should trigger synchronization. ADL_GLSYNC_TRIGGEREDGE_* \ref define_glsync + int iTriggerEdge; +/// Scan rate multiplier applied to the sync signal. ADL_GLSYNC_SCANRATECOEFF_* \ref define_glsync + int iScanRateCoeff; +}ADLGLSyncGenlockConfig, *LPADLGLSyncGenlockConfig; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing GL-Sync port information. +/// +/// This structure is used to get status of the GL-Sync ports (BNC or RJ45s) +/// for Workstation Framelock/Genlock. +/// \see define_glsync +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLGlSyncPortInfo +{ +/// Type of GL-Sync port (ADL_GLSYNC_PORT_*). + int iPortType; +/// The number of LEDs for this port. It's also filled within ADLGLSyncPortCaps. + int iNumOfLEDs; +/// Port state ADL_GLSYNC_PORTSTATE_* \ref define_glsync + int iPortState; +/// Scanned frequency for this port (vertical refresh rate in milliHz; 60000 means 60 Hz). + int iFrequency; +/// Used for ADL_GLSYNC_PORT_BNC. It is ADL_GLSYNC_SIGNALTYPE_* \ref define_glsync + int iSignalType; +/// Used for ADL_GLSYNC_PORT_RJ45PORT*. It is GL_Sync GPU Port index or ADL_GLSYNC_SIGNALSOURCE_*. \ref define_glsync + int iSignalSource; + +} ADLGlSyncPortInfo, *LPADLGlSyncPortInfo; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing GL-Sync port control settings. +/// +/// This structure is used to configure the GL-Sync ports (RJ45s only) +/// for Workstation Framelock/Genlock. +/// \see define_glsync +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLGlSyncPortControl +{ +/// Port to control ADL_GLSYNC_PORT_RJ45PORT1 or ADL_GLSYNC_PORT_RJ45PORT2 \ref define_glsync + int iPortType; +/// Port control data ADL_GLSYNC_PORTCNTL_* \ref define_glsync + int iControlVector; +/// Source of the sync signal. Either GL_Sync GPU Port index or ADL_GLSYNC_SIGNALSOURCE_* \ref define_glsync + int iSignalSource; +} ADLGlSyncPortControl; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing GL-Sync mode of a display. +/// +/// This structure is used to get and set GL-Sync mode settings for a display connected to +/// an adapter attached to a GL-Sync module for Workstation Framelock/Genlock. +/// \see define_glsync +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLGlSyncMode +{ +/// Mode control vector. Bitfield of ADL_GLSYNC_MODECNTL_* \ref define_glsync + int iControlVector; +/// Mode status vector. Bitfield of ADL_GLSYNC_MODECNTL_STATUS_* \ref define_glsync + int iStatusVector; +/// Index of GL-Sync connector used to genlock the display/controller. + int iGLSyncConnectorIndex; +} ADLGlSyncMode, *LPADLGlSyncMode; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing GL-Sync mode of a display. +/// +/// This structure is used to get and set GL-Sync mode settings for a display connected to +/// an adapter attached to a GL-Sync module for Workstation Framelock/Genlock. +/// \see define_glsync +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLGlSyncMode2 +{ +/// Mode control vector. Bitfield of ADL_GLSYNC_MODECNTL_* \ref define_glsync + int iControlVector; +/// Mode status vector. Bitfield of ADL_GLSYNC_MODECNTL_STATUS_* \ref define_glsync + int iStatusVector; +/// Index of GL-Sync connector used to genlock the display/controller. + int iGLSyncConnectorIndex; +/// Index of the display to which this GLSync applies to. + int iDisplayIndex; +} ADLGlSyncMode2, *LPADLGlSyncMode2; + + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing the packet info of a display. +/// +/// This structure is used to get and set the packet information of a display. +/// This structure is used by ADLDisplayDataPacket. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLInfoPacket +{ + char hb0; + char hb1; + char hb2; +/// sb0~sb27 + char sb[28]; +}ADLInfoPacket; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing the AVI packet info of a display. +/// +/// This structure is used to get and set AVI the packet info of a display. +/// This structure is used by ADLDisplayDataPacket. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLAVIInfoPacket //Valid user defined data/ +{ +/// byte 3, bit 7 + char bPB3_ITC; +/// byte 5, bit [7:4]. + char bPB5; +}ADLAVIInfoPacket; + +// Overdrive clock setting structure definition. + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing the Overdrive clock setting. +/// +/// This structure is used to get the Overdrive clock setting. +/// This structure is used by ADLAdapterODClockInfo. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLODClockSetting +{ +/// Deafult clock + int iDefaultClock; +/// Current clock + int iCurrentClock; +/// Maximum clcok + int iMaxClock; +/// Minimum clock + int iMinClock; +/// Requested clcock + int iRequestedClock; +/// Step + int iStepClock; +} ADLODClockSetting; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing the Overdrive clock information. +/// +/// This structure is used to get the Overdrive clock information. +/// This structure is used by the ADL_Display_ODClockInfo_Get() function. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLAdapterODClockInfo +{ +/// Size of the structure + int iSize; +/// Flag \ref define_clockinfo_flags + int iFlags; +/// Memory Clock + ADLODClockSetting sMemoryClock; +/// Engine Clock + ADLODClockSetting sEngineClock; +} ADLAdapterODClockInfo; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing the Overdrive clock configuration. +/// +/// This structure is used to set the Overdrive clock configuration. +/// This structure is used by the ADL_Display_ODClockConfig_Set() function. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLAdapterODClockConfig +{ +/// Size of the structure + int iSize; +/// Flag \ref define_clockinfo_flags + int iFlags; +/// Memory Clock + int iMemoryClock; +/// Engine Clock + int iEngineClock; +} ADLAdapterODClockConfig; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about current power management related activity. +/// +/// This structure is used to store information about current power management related activity. +/// This structure (Overdrive 5 interfaces) is used by the ADL_PM_CurrentActivity_Get() function. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLPMActivity +{ +/// Must be set to the size of the structure + int iSize; +/// Current engine clock. + int iEngineClock; +/// Current memory clock. + int iMemoryClock; +/// Current core voltage. + int iVddc; +/// GPU utilization. + int iActivityPercent; +/// Performance level index. + int iCurrentPerformanceLevel; +/// Current PCIE bus speed. + int iCurrentBusSpeed; +/// Number of PCIE bus lanes. + int iCurrentBusLanes; +/// Maximum number of PCIE bus lanes. + int iMaximumBusLanes; +/// Reserved for future purposes. + int iReserved; +} ADLPMActivity; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about thermal controller. +/// +/// This structure is used to store information about thermal controller. +/// This structure is used by ADL_PM_ThermalDevices_Enum. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLThermalControllerInfo +{ +/// Must be set to the size of the structure + int iSize; +/// Possible valies: \ref ADL_DL_THERMAL_DOMAIN_OTHER or \ref ADL_DL_THERMAL_DOMAIN_GPU. + int iThermalDomain; +/// GPU 0, 1, etc. + int iDomainIndex; +/// Possible valies: \ref ADL_DL_THERMAL_FLAG_INTERRUPT or \ref ADL_DL_THERMAL_FLAG_FANCONTROL + int iFlags; +} ADLThermalControllerInfo; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about thermal controller temperature. +/// +/// This structure is used to store information about thermal controller temperature. +/// This structure is used by the ADL_PM_Temperature_Get() function. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLTemperature +{ +/// Must be set to the size of the structure + int iSize; +/// Temperature in millidegrees Celsius. + int iTemperature; +} ADLTemperature; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about thermal controller fan speed. +/// +/// This structure is used to store information about thermal controller fan speed. +/// This structure is used by the ADL_PM_FanSpeedInfo_Get() function. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLFanSpeedInfo +{ +/// Must be set to the size of the structure + int iSize; +/// \ref define_fanctrl + int iFlags; +/// Minimum possible fan speed value in percents. + int iMinPercent; +/// Maximum possible fan speed value in percents. + int iMaxPercent; +/// Minimum possible fan speed value in RPM. + int iMinRPM; +/// Maximum possible fan speed value in RPM. + int iMaxRPM; +} ADLFanSpeedInfo; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about fan speed reported by thermal controller. +/// +/// This structure is used to store information about fan speed reported by thermal controller. +/// This structure is used by the ADL_Overdrive5_FanSpeed_Get() and ADL_Overdrive5_FanSpeed_Set() functions. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLFanSpeedValue +{ +/// Must be set to the size of the structure + int iSize; +/// Possible valies: \ref ADL_DL_FANCTRL_SPEED_TYPE_PERCENT or \ref ADL_DL_FANCTRL_SPEED_TYPE_RPM + int iSpeedType; +/// Fan speed value + int iFanSpeed; +/// The only flag for now is: \ref ADL_DL_FANCTRL_FLAG_USER_DEFINED_SPEED + int iFlags; +} ADLFanSpeedValue; + +//////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing the range of Overdrive parameter. +/// +/// This structure is used to store information about the range of Overdrive parameter. +/// This structure is used by ADLODParameters. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLODParameterRange +{ +/// Minimum parameter value. + int iMin; +/// Maximum parameter value. + int iMax; +/// Parameter step value. + int iStep; +} ADLODParameterRange; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about Overdrive parameters. +/// +/// This structure is used to store information about Overdrive parameters. +/// This structure is used by the ADL_Overdrive5_ODParameters_Get() function. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLODParameters +{ +/// Must be set to the size of the structure + int iSize; +/// Number of standard performance states. + int iNumberOfPerformanceLevels; +/// Indicates whether the GPU is capable to measure its activity. + int iActivityReportingSupported; +/// Indicates whether the GPU supports discrete performance levels or performance range. + int iDiscretePerformanceLevels; +/// Reserved for future use. + int iReserved; +/// Engine clock range. + ADLODParameterRange sEngineClock; +/// Memory clock range. + ADLODParameterRange sMemoryClock; +/// Core voltage range. + ADLODParameterRange sVddc; +} ADLODParameters; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about Overdrive level. +/// +/// This structure is used to store information about Overdrive level. +/// This structure is used by ADLODPerformanceLevels. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLODPerformanceLevel +{ +/// Engine clock. + int iEngineClock; +/// Memory clock. + int iMemoryClock; +/// Core voltage. + int iVddc; +} ADLODPerformanceLevel; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about Overdrive performance levels. +/// +/// This structure is used to store information about Overdrive performance levels. +/// This structure is used by the ADL_Overdrive5_ODPerformanceLevels_Get() and ADL_Overdrive5_ODPerformanceLevels_Set() functions. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLODPerformanceLevels +{ +/// Must be set to sizeof( \ref ADLODPerformanceLevels ) + sizeof( \ref ADLODPerformanceLevel ) * (ADLODParameters.iNumberOfPerformanceLevels - 1) + int iSize; + int iReserved; +/// Array of performance state descriptors. Must have ADLODParameters.iNumberOfPerformanceLevels elements. + ADLODPerformanceLevel aLevels [1]; +} ADLODPerformanceLevels; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about the proper CrossfireX chains combinations. +/// +/// This structure is used to store information about the CrossfireX chains combination for a particular adapter. +/// This structure is used by the ADL_Adapter_Crossfire_Caps(), ADL_Adapter_Crossfire_Get(), and ADL_Adapter_Crossfire_Set() functions. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLCrossfireComb +{ +/// Number of adapters in this combination. + int iNumLinkAdapter; +/// A list of ADL indexes of the linked adapters in this combination. + int iAdaptLink[3]; +} ADLCrossfireComb; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing CrossfireX state and error information. +/// +/// This structure is used to store state and error information about a particular adapter CrossfireX combination. +/// This structure is used by the ADL_Adapter_Crossfire_Get() function. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLCrossfireInfo +{ +/// Current error code of this CrossfireX combination. + int iErrorCode; +/// Current \ref define_crossfirestate + int iState; +/// If CrossfireX is supported by this combination. The value is either \ref ADL_TRUE or \ref ADL_FALSE. + int iSupported; +} ADLCrossfireInfo; + +///////////////////////////////////////////////////////////////////////////////////////////// +/// \brief Structure containing information about the BIOS. +/// +/// This structure is used to store various information about the Chipset. This +/// information can be returned to the user. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLBiosInfo +{ + char strPartNumber[ADL_MAX_PATH]; ///< Part number. + char strVersion[ADL_MAX_PATH]; ///< Version number. + char strDate[ADL_MAX_PATH]; ///< BIOS date in yyyy/mm/dd hh:mm format. +} ADLBiosInfo, *LPADLBiosInfo; + + +///////////////////////////////////////////////////////////////////////////////////////////// +/// \brief Structure containing information about adapter location. +/// +/// This structure is used to store information about adapter location. +/// This structure is used by ADLMVPUStatus. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLAdapterLocation +{ +/// PCI Bus number : 8 bits + int iBus; +/// Device number : 5 bits + int iDevice; +/// Function number : 3 bits + int iFunction; +} ADLAdapterLocation,ADLBdf; + + +///////////////////////////////////////////////////////////////////////////////////////////// +/// \brief Structure containing information about MultiVPU capabilities. +/// +/// This structure is used to store information about MultiVPU capabilities. +/// This structure is used by the ADL_Display_MVPUCaps_Get() function. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLMVPUCaps +{ +/// Must be set to sizeof( ADLMVPUCaps ). + int iSize; +/// Number of adapters. + int iAdapterCount; +/// Bits set for all possible MVPU masters. \ref MVPU_ADAPTER_0 .. \ref MVPU_ADAPTER_3 + int iPossibleMVPUMasters; +/// Bits set for all possible MVPU slaves. \ref MVPU_ADAPTER_0 .. \ref MVPU_ADAPTER_3 + int iPossibleMVPUSlaves; +/// Registry path for each adapter. + char cAdapterPath[ADL_DL_MAX_MVPU_ADAPTERS][ADL_DL_MAX_REGISTRY_PATH]; +} ADLMVPUCaps; + +///////////////////////////////////////////////////////////////////////////////////////////// +/// \brief Structure containing information about MultiVPU status. +/// +/// This structure is used to store information about MultiVPU status. +/// Ths structure is used by the ADL_Display_MVPUStatus_Get() function. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLMVPUStatus +{ +/// Must be set to sizeof( ADLMVPUStatus ). + int iSize; +/// Number of active adapters. + int iActiveAdapterCount; +/// MVPU status. + int iStatus; +/// PCI Bus/Device/Function for each active adapter participating in MVPU. + ADLAdapterLocation aAdapterLocation[ADL_DL_MAX_MVPU_ADAPTERS]; +} ADLMVPUStatus; + +// Displays Manager structures + +/////////////////////////////////////////////////////////////////////////// +/// \brief Structure containing information about the activatable source. +/// +/// This structure is used to store activatable source information +/// This information can be returned to the user. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLActivatableSource +{ + /// The Persistent logical Adapter Index. + int iAdapterIndex; + /// The number of Activatable Sources. + int iNumActivatableSources; + /// The bit mask identifies the number of bits ActivatableSourceValue is using. (Not currnetly used) + int iActivatableSourceMask; + /// The bit mask identifies the status. (Not currnetly used) + int iActivatableSourceValue; +} ADLActivatableSource, *LPADLActivatableSource; + +///////////////////////////////////////////////////////////////////////////////////////////// +/// \brief Structure containing information about display mode. +/// +/// This structure is used to store the display mode for the current adapter +/// such as X, Y positions, screen resolutions, orientation, +/// color depth, refresh rate, progressive or interlace mode, etc. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// + +typedef struct ADLMode +{ +/// Adapter index. + int iAdapterIndex; +/// Display IDs. + ADLDisplayID displayID; +/// Screen position X coordinate. + int iXPos; +/// Screen position Y coordinate. + int iYPos; +/// Screen resolution Width. + int iXRes; +/// Screen resolution Height. + int iYRes; +/// Screen Color Depth. E.g., 16, 32. + int iColourDepth; +/// Screen refresh rate. Could be fractional E.g. 59.97 + float fRefreshRate; +/// Screen orientation. E.g., 0, 90, 180, 270. + int iOrientation; +/// Vista mode flag indicating Progressive or Interlaced mode. + int iModeFlag; +/// The bit mask identifying the number of bits this Mode is currently using. It is the sum of all the bit definitions defined in \ref define_displaymode + int iModeMask; +/// The bit mask identifying the display status. The detailed definition is in \ref define_displaymode + int iModeValue; +} ADLMode, *LPADLMode; + + +///////////////////////////////////////////////////////////////////////////////////////////// +/// \brief Structure containing information about display target information. +/// +/// This structure is used to store the display target information. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLDisplayTarget +{ + /// The Display ID. + ADLDisplayID displayID; + + /// The display map index identify this manner and the desktop surface. + int iDisplayMapIndex; + + /// The bit mask identifies the number of bits DisplayTarget is currently using. It is the sum of all the bit definitions defined in \ref ADL_DISPLAY_DISPLAYTARGET_PREFERRED. + int iDisplayTargetMask; + + /// The bit mask identifies the display status. The detailed definition is in \ref ADL_DISPLAY_DISPLAYTARGET_PREFERRED. + int iDisplayTargetValue; + +} ADLDisplayTarget, *LPADLDisplayTarget; + + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about the display SLS bezel Mode information. +/// +/// This structure is used to store the display SLS bezel Mode information. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct tagADLBezelTransientMode +{ + /// Adapter Index + int iAdapterIndex; + + /// SLS Map Index + int iSLSMapIndex; + + /// The mode index + int iSLSModeIndex; + + /// The mode + ADLMode displayMode; + + /// The number of bezel offsets belongs to this map + int iNumBezelOffset; + + /// The first bezel offset array index in the native mode array + int iFirstBezelOffsetArrayIndex; + + /// The bit mask identifies the bits this structure is currently using. It will be the total OR of all the bit definitions. + int iSLSBezelTransientModeMask; + + /// The bit mask identifies the display status. The detail definition is defined below. + int iSLSBezelTransientModeValue; + +} ADLBezelTransientMode, *LPADLBezelTransientMode; + + +///////////////////////////////////////////////////////////////////////////////////////////// +/// \brief Structure containing information about the adapter display manner. +/// +/// This structure is used to store adapter display manner information +/// This information can be returned to the user. Alternatively, it can be used to access various driver calls to +/// fetch various display device related display manner settings upon the user's request. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLAdapterDisplayCap +{ + /// The Persistent logical Adapter Index. + int iAdapterIndex; + /// The bit mask identifies the number of bits AdapterDisplayCap is currently using. Sum all the bits defined in ADL_ADAPTER_DISPLAYCAP_XXX + int iAdapterDisplayCapMask; + /// The bit mask identifies the status. Refer to ADL_ADAPTER_DISPLAYCAP_XXX + int iAdapterDisplayCapValue; +} ADLAdapterDisplayCap, *LPADLAdapterDisplayCap; + + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about display mapping. +/// +/// This structure is used to store the display mapping data such as display manner. +/// For displays with horizontal or vertical stretch manner, +/// this structure also stores the display order, display row, and column data. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLDisplayMap +{ +/// The current display map index. It is the OS desktop index. For example, if the OS index 1 is showing clone mode, the display map will be 1. + int iDisplayMapIndex; + +/// The Display Mode for the current map + ADLMode displayMode; + +/// The number of display targets belongs to this map\n + int iNumDisplayTarget; + +/// The first target array index in the Target array\n + int iFirstDisplayTargetArrayIndex; + +/// The bit mask identifies the number of bits DisplayMap is currently using. It is the sum of all the bit definitions defined in ADL_DISPLAY_DISPLAYMAP_MANNER_xxx. + int iDisplayMapMask; + +///The bit mask identifies the display status. The detailed definition is in ADL_DISPLAY_DISPLAYMAP_MANNER_xxx. + int iDisplayMapValue; + +} ADLDisplayMap, *LPADLDisplayMap; + + +///////////////////////////////////////////////////////////////////////////////////////////// +/// \brief Structure containing information about the display device possible map for one GPU +/// +/// This structure is used to store the display device possible map +/// This information can be returned to the user. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLPossibleMap +{ + /// The current PossibleMap index. Each PossibleMap is assigned an index + int iIndex; + /// The adapter index identifying the GPU for which to validate these Maps & Targets + int iAdapterIndex; + /// Number of display Maps for this GPU to be validated + int iNumDisplayMap; + /// The display Maps list to validate + ADLDisplayMap* displayMap; + /// the number of display Targets for these display Maps + int iNumDisplayTarget; + /// The display Targets list for these display Maps to be validated. + ADLDisplayTarget* displayTarget; +} ADLPossibleMap, *LPADLPossibleMap; + + +///////////////////////////////////////////////////////////////////////////////////////////// +/// \brief Structure containing information about display possible mapping. +/// +/// This structure is used to store the display possible mapping's controller index for the current display. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLPossibleMapping +{ + int iDisplayIndex; ///< The display index. Each display is assigned an index. + int iDisplayControllerIndex; ///< The controller index to which display is mapped. + int iDisplayMannerSupported; ///< The supported display manner. +} ADLPossibleMapping, *LPADLPossibleMapping; + +///////////////////////////////////////////////////////////////////////////////////////////// +/// \brief Structure containing information about the validated display device possible map result. +/// +/// This structure is used to store the validated display device possible map result +/// This information can be returned to the user. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLPossibleMapResult +{ + /// The current display map index. It is the OS Desktop index. For example, OS Index 1 showing clone mode. The Display Map will be 1. + int iIndex; + // The bit mask identifies the number of bits PossibleMapResult is currently using. It will be the sum all the bit definitions defined in ADL_DISPLAY_POSSIBLEMAPRESULT_VALID. + int iPossibleMapResultMask; + /// The bit mask identifies the possible map result. The detail definition is defined in ADL_DISPLAY_POSSIBLEMAPRESULT_XXX. + int iPossibleMapResultValue; +} ADLPossibleMapResult, *LPADLPossibleMapResult; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about the display SLS Grid information. +/// +/// This structure is used to store the display SLS Grid information. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLSLSGrid +{ +/// The Adapter index. + int iAdapterIndex; + +/// The grid index. + int iSLSGridIndex; + +/// The grid row. + int iSLSGridRow; + +/// The grid column. + int iSLSGridColumn; + +/// The grid bit mask identifies the number of bits DisplayMap is currently using. Sum of all bits defined in ADL_DISPLAY_SLSGRID_ORIENTATION_XXX + int iSLSGridMask; + +/// The grid bit value identifies the display status. Refer to ADL_DISPLAY_SLSGRID_ORIENTATION_XXX + int iSLSGridValue; + +} ADLSLSGrid, *LPADLSLSGrid; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about the display SLS Map information. +/// +/// This structure is used to store the display SLS Map information. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLSLSMap +{ + /// The Adapter Index + int iAdapterIndex; + + /// The current display map index. It is the OS Desktop index. For example, OS Index 1 showing clone mode. The Display Map will be 1. + int iSLSMapIndex; + + /// Indicate the current grid + ADLSLSGrid grid; + + /// OS surface index + int iSurfaceMapIndex; + + /// Screen orientation. E.g., 0, 90, 180, 270 + int iOrientation; + + /// The number of display targets belongs to this map + int iNumSLSTarget; + + /// The first target array index in the Target array + int iFirstSLSTargetArrayIndex; + + /// The number of native modes belongs to this map + int iNumNativeMode; + + /// The first native mode array index in the native mode array + int iFirstNativeModeArrayIndex; + + /// The number of bezel modes belongs to this map + int iNumBezelMode; + + /// The first bezel mode array index in the native mode array + int iFirstBezelModeArrayIndex; + + /// The number of bezel offsets belongs to this map + int iNumBezelOffset; + + /// The first bezel offset array index in the + int iFirstBezelOffsetArrayIndex; + + /// The bit mask identifies the number of bits DisplayMap is currently using. Sum all the bit definitions defined in ADL_DISPLAY_SLSMAP_XXX. + int iSLSMapMask; + + /// The bit mask identifies the display map status. Refer to ADL_DISPLAY_SLSMAP_XXX + int iSLSMapValue; + + +} ADLSLSMap, *LPADLSLSMap; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about the display SLS Offset information. +/// +/// This structure is used to store the display SLS Offset information. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLSLSOffset +{ + /// The Adapter Index + int iAdapterIndex; + + /// The current display map index. It is the OS Desktop index. For example, OS Index 1 showing clone mode. The Display Map will be 1. + int iSLSMapIndex; + + /// The Display ID. + ADLDisplayID displayID; + + /// SLS Bezel Mode Index + int iBezelModeIndex; + + /// SLS Bezel Offset X + int iBezelOffsetX; + + /// SLS Bezel Offset Y + int iBezelOffsetY; + + /// SLS Display Width + int iDisplayWidth; + + /// SLS Display Height + int iDisplayHeight; + + /// The bit mask identifies the number of bits Offset is currently using. + int iBezelOffsetMask; + + /// The bit mask identifies the display status. + int iBezelffsetValue; +} ADLSLSOffset, *LPADLSLSOffset; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about the display SLS Mode information. +/// +/// This structure is used to store the display SLS Mode information. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLSLSMode +{ + /// The Adapter Index + int iAdapterIndex; + + /// The current display map index. It is the OS Desktop index. For example, OS Index 1 showing clone mode. The Display Map will be 1. + int iSLSMapIndex; + + /// The mode index + int iSLSModeIndex; + + /// The mode for this map. + ADLMode displayMode; + + /// The bit mask identifies the number of bits Mode is currently using. + int iSLSNativeModeMask; + + /// The bit mask identifies the display status. + int iSLSNativeModeValue; +} ADLSLSMode, *LPADLSLSMode; + + + + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about the display Possible SLS Map information. +/// +/// This structure is used to store the display Possible SLS Map information. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLPossibleSLSMap +{ + /// The current display map index. It is the OS Desktop index. + /// For example, OS Index 1 showing clone mode. The Display Map will be 1. + int iSLSMapIndex; + + /// Number of display map to be validated. + int iNumSLSMap; + + /// The display map list for validation + ADLSLSMap* lpSLSMap; + + /// the number of display map config to be validated. + int iNumSLSTarget; + + /// The display target list for validation. + ADLDisplayTarget* lpDisplayTarget; +} ADLPossibleSLSMap, *LPADLPossibleSLSMap; + + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about the SLS targets. +/// +/// This structure is used to store the SLS targets information. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLSLSTarget +{ + /// the logic adapter index + int iAdapterIndex; + + /// The SLS map index + int iSLSMapIndex; + + /// The target ID + ADLDisplayTarget displayTarget; + + /// Target postion X in SLS grid + int iSLSGridPositionX; + + /// Target postion Y in SLS grid + int iSLSGridPositionY; + + /// The view size width, height and rotation angle per SLS Target + ADLMode viewSize; + + /// The bit mask identifies the bits in iSLSTargetValue are currently used + int iSLSTargetMask; + + /// The bit mask identifies status info. It is for function extension purpose + int iSLSTargetValue; + +} ADLSLSTarget, *LPADLSLSTarget; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about the Adapter offset stepping size. +/// +/// This structure is used to store the Adapter offset stepping size information. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLBezelOffsetSteppingSize +{ + /// the logic adapter index + int iAdapterIndex; + + /// The SLS map index + int iSLSMapIndex; + + /// Bezel X stepping size offset + int iBezelOffsetSteppingSizeX; + + /// Bezel Y stepping size offset + int iBezelOffsetSteppingSizeY; + + /// Identifies the bits this structure is currently using. It will be the total OR of all the bit definitions. + int iBezelOffsetSteppingSizeMask; + + /// Bit mask identifies the display status. + int iBezelOffsetSteppingSizeValue; + +} ADLBezelOffsetSteppingSize, *LPADLBezelOffsetSteppingSize; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about driver supported PowerExpress Config Caps +/// +/// This structure is used to store the driver supported PowerExpress Config Caps +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLPXConfigCaps +{ + /// The Persistent logical Adapter Index. + int iAdapterIndex; + + /// The bit mask identifies the number of bits PowerExpress Config Caps is currently using. It is the sum of all the bit definitions defined in \ref ADL_PX_CONFIGCAPS_XXXX. + int iPXConfigCapMask; + + /// The bit mask identifies the PowerExpress Config Caps value. The detailed definition is in \ref ADL_PX_CONFIGCAPS_XXXX. + int iPXConfigCapValue; + +} ADLPXConfigCaps, *LPADLPXConfigCaps; + + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about an application +/// +/// This structure is used to store basic information of an application +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct _ADLApplicationData +{ + /// Path Name + char strPathName[ADL_MAX_PATH]; + /// File Name + char strFileName[ADL_APP_PROFILE_FILENAME_LENGTH]; + /// Creation timestamp + char strTimeStamp[ADL_APP_PROFILE_TIMESTAMP_LENGTH]; + /// Version + char strVersion[ADL_APP_PROFILE_VERSION_LENGTH]; +}ADLApplicationData; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about an application +/// +/// This structure is used to store basic information of an application +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct _ADLApplicationDataX2 +{ + /// Path Name + wchar_t strPathName[ADL_MAX_PATH]; + /// File Name + wchar_t strFileName[ADL_APP_PROFILE_FILENAME_LENGTH]; + /// Creation timestamp + wchar_t strTimeStamp[ADL_APP_PROFILE_TIMESTAMP_LENGTH]; + /// Version + wchar_t strVersion[ADL_APP_PROFILE_VERSION_LENGTH]; +}ADLApplicationDataX2; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information of a property of an application profile +/// +/// This structure is used to store property information of an application profile +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct _PropertyRecord +{ + /// Property Name + char strName [ADL_APP_PROFILE_PROPERTY_LENGTH]; + /// Property Type + ADLProfilePropertyType eType; + /// Data Size in bytes + int iDataSize; + /// Property Value, can be any data type + unsigned char uData[1]; +}PropertyRecord; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about an application profile +/// +/// This structure is used to store information of an application profile +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct _ADLApplicationProfile +{ + /// Number of properties + int iCount; + /// Buffer to store all property records + PropertyRecord record[1]; +}ADLApplicationProfile; + +// @} + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about an OD5 Power Control feature +/// +/// This structure is used to store information of an Power Control feature +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLPowerControlInfo +{ +/// Minimum value. +int iMinValue; +/// Maximum value. +int iMaxValue; +/// The minimum change in between minValue and maxValue. +int iStepValue; + } ADLPowerControlInfo; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about an controller mode +/// +/// This structure is used to store information of an controller mode +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct _ADLControllerMode +{ + /// This falg indicates actions that will be applied by set viewport + /// The value can be a combination of ADL_CONTROLLERMODE_CM_MODIFIER_VIEW_POSITION, + /// ADL_CONTROLLERMODE_CM_MODIFIER_VIEW_PANLOCK and ADL_CONTROLLERMODE_CM_MODIFIER_VIEW_SIZE + int iModifiers; + + /// Horizontal view starting position + int iViewPositionCx; + + /// Vertical view starting position + int iViewPositionCy; + + /// Horizontal left panlock position + int iViewPanLockLeft; + + /// Horizontal right panlock position + int iViewPanLockRight; + + /// Vertical top panlock position + int iViewPanLockTop; + + /// Vertical bottom panlock position + int iViewPanLockBottom; + + /// View resolution in pixels (width) + int iViewResolutionCx; + + /// View resolution in pixels (hight) + int iViewResolutionCy; +}ADLControllerMode; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about a display +/// +/// This structure is used to store information about a display +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLDisplayIdentifier +{ + /// ADL display index + long ulDisplayIndex; + + /// manufacturer ID of the display + long ulManufacturerId; + + /// product ID of the display + long ulProductId; + + /// serial number of the display + long ulSerialNo; + +} ADLDisplayIdentifier; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about Overdrive 6 clock range +/// +/// This structure is used to store information about Overdrive 6 clock range +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct _ADLOD6ParameterRange +{ + /// The starting value of the clock range + int iMin; + /// The ending value of the clock range + int iMax; + /// The minimum increment between clock values + int iStep; + +} ADLOD6ParameterRange; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about Overdrive 6 capabilities +/// +/// This structure is used to store information about Overdrive 6 capabilities +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct _ADLOD6Capabilities +{ + /// Contains a bitmap of the OD6 capability flags. Possible values: \ref ADL_OD6_CAPABILITY_SCLK_CUSTOMIZATION, + /// \ref ADL_OD6_CAPABILITY_MCLK_CUSTOMIZATION, \ref ADL_OD6_CAPABILITY_GPU_ACTIVITY_MONITOR + int iCapabilities; + /// Contains a bitmap indicating the power states + /// supported by OD6. Currently only the performance state + /// is supported. Possible Values: \ref ADL_OD6_SUPPORTEDSTATE_PERFORMANCE + int iSupportedStates; + /// Number of levels. OD6 will always use 2 levels, which describe + /// the minimum to maximum clock ranges. + /// The 1st level indicates the minimum clocks, and the 2nd level + /// indicates the maximum clocks. + int iNumberOfPerformanceLevels; + /// Contains the hard limits of the sclk range. Overdrive + /// clocks cannot be set outside this range. + ADLOD6ParameterRange sEngineClockRange; + /// Contains the hard limits of the mclk range. Overdrive + /// clocks cannot be set outside this range. + ADLOD6ParameterRange sMemoryClockRange; + + /// Value for future extension + int iExtValue; + /// Mask for future extension + int iExtMask; + +} ADLOD6Capabilities; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about Overdrive 6 clock values. +/// +/// This structure is used to store information about Overdrive 6 clock values. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct _ADLOD6PerformanceLevel +{ + /// Engine (core) clock. + int iEngineClock; + /// Memory clock. + int iMemoryClock; + +} ADLOD6PerformanceLevel; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about Overdrive 6 clocks. +/// +/// This structure is used to store information about Overdrive 6 clocks. This is a +/// variable-sized structure. iNumberOfPerformanceLevels indicate how many elements +/// are contained in the aLevels array. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct _ADLOD6StateInfo +{ + /// Number of levels. OD6 uses clock ranges instead of discrete performance levels. + /// iNumberOfPerformanceLevels is always 2. The 1st level indicates the minimum clocks + /// in the range. The 2nd level indicates the maximum clocks in the range. + int iNumberOfPerformanceLevels; + + /// Value for future extension + int iExtValue; + /// Mask for future extension + int iExtMask; + + /// Variable-sized array of levels. + /// The number of elements in the array is specified by iNumberofPerformanceLevels. + ADLOD6PerformanceLevel aLevels [1]; + +} ADLOD6StateInfo; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about current Overdrive 6 performance status. +/// +/// This structure is used to store information about current Overdrive 6 performance status. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct _ADLOD6CurrentStatus +{ + /// Current engine clock + int iEngineClock; + /// Current memory clock + int iMemoryClock; + /// Current GPU activity in percent. This + /// indicates how "busy" the GPU is. + int iActivityPercent; + /// Not used. Reserved for future use. + int iCurrentPerformanceLevel; + /// Current PCI-E bus speed + int iCurrentBusSpeed; + /// Current PCI-E bus # of lanes + int iCurrentBusLanes; + /// Maximum possible PCI-E bus # of lanes + int iMaximumBusLanes; + + /// Value for future extension + int iExtValue; + /// Mask for future extension + int iExtMask; + +} ADLOD6CurrentStatus; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about Overdrive 6 thermal contoller capabilities +/// +/// This structure is used to store information about Overdrive 6 thermal controller capabilities +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct _ADLOD6ThermalControllerCaps +{ + /// Contains a bitmap of thermal controller capability flags. Possible values: \ref ADL_OD6_TCCAPS_THERMAL_CONTROLLER, \ref ADL_OD6_TCCAPS_FANSPEED_CONTROL, + /// \ref ADL_OD6_TCCAPS_FANSPEED_PERCENT_READ, \ref ADL_OD6_TCCAPS_FANSPEED_PERCENT_WRITE, \ref ADL_OD6_TCCAPS_FANSPEED_RPM_READ, \ref ADL_OD6_TCCAPS_FANSPEED_RPM_WRITE + int iCapabilities; + /// Minimum fan speed expressed as a percentage + int iFanMinPercent; + /// Maximum fan speed expressed as a percentage + int iFanMaxPercent; + /// Minimum fan speed expressed in revolutions-per-minute + int iFanMinRPM; + /// Maximum fan speed expressed in revolutions-per-minute + int iFanMaxRPM; + + /// Value for future extension + int iExtValue; + /// Mask for future extension + int iExtMask; + +} ADLOD6ThermalControllerCaps; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about Overdrive 6 fan speed information +/// +/// This structure is used to store information about Overdrive 6 fan speed information +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct _ADLOD6FanSpeedInfo +{ + /// Contains a bitmap of the valid fan speed type flags. Possible values: \ref ADL_OD6_FANSPEED_TYPE_PERCENT, \ref ADL_OD6_FANSPEED_TYPE_RPM, \ref ADL_OD6_FANSPEED_USER_DEFINED + int iSpeedType; + /// Contains current fan speed in percent (if valid flag exists in iSpeedType) + int iFanSpeedPercent; + /// Contains current fan speed in RPM (if valid flag exists in iSpeedType) + int iFanSpeedRPM; + + /// Value for future extension + int iExtValue; + /// Mask for future extension + int iExtMask; + +} ADLOD6FanSpeedInfo; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about Overdrive 6 fan speed value +/// +/// This structure is used to store information about Overdrive 6 fan speed value +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct _ADLOD6FanSpeedValue +{ + /// Indicates the units of the fan speed. Possible values: \ref ADL_OD6_FANSPEED_TYPE_PERCENT, \ref ADL_OD6_FANSPEED_TYPE_RPM + int iSpeedType; + /// Fan speed value (units as indicated above) + int iFanSpeed; + + /// Value for future extension + int iExtValue; + /// Mask for future extension + int iExtMask; + +} ADLOD6FanSpeedValue; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about Overdrive 6 PowerControl settings. +/// +/// This structure is used to store information about Overdrive 6 PowerControl settings. +/// PowerControl is the feature which allows the performance characteristics of the GPU +/// to be adjusted by changing the PowerTune power limits. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct _ADLOD6PowerControlInfo +{ + /// The minimum PowerControl adjustment value + int iMinValue; + /// The maximum PowerControl adjustment value + int iMaxValue; + /// The minimum difference between PowerControl adjustment values + int iStepValue; + + /// Value for future extension + int iExtValue; + /// Mask for future extension + int iExtMask; + +} ADLOD6PowerControlInfo; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about Overdrive 6 PowerControl settings. +/// +/// This structure is used to store information about Overdrive 6 PowerControl settings. +/// PowerControl is the feature which allows the performance characteristics of the GPU +/// to be adjusted by changing the PowerTune power limits. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct _ADLOD6VoltageControlInfo +{ + /// The minimum VoltageControl adjustment value + int iMinValue; + /// The maximum VoltageControl adjustment value + int iMaxValue; + /// The minimum difference between VoltageControl adjustment values + int iStepValue; + + /// Value for future extension + int iExtValue; + /// Mask for future extension + int iExtMask; + +} ADLOD6VoltageControlInfo; + +//////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing ECC statistics namely SEC counts and DED counts +/// Single error count - count of errors that can be corrected +/// Doubt Error Detect - count of errors that cannot be corrected +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct _ADLECCData +{ + // Single error count - count of errors that can be corrected + int iSec; + // Double error detect - count of errors that cannot be corrected + int iDed; + +} ADLECCData; + + +/// \brief Handle to ADL client context. +/// +/// ADL clients obtain context handle from initial call to \ref ADL2_Main_Control_Create. +/// Clients have to pass the handle to each subsequent ADL call and finally destroy +/// the context with call to \ref ADL2_Main_Control_Destroy +/// \nosubgrouping +typedef void *ADL_CONTEXT_HANDLE; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing the display mode definition used per controller. +/// +/// This structure is used to store the display mode definition used per controller. +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct ADLDisplayModeX2 +{ +/// Horizontal resolution (in pixels). + int iWidth; +/// Vertical resolution (in lines). + int iHeight; +/// Interlaced/Progressive. The value will be set for Interlaced as ADL_DL_TIMINGFLAG_INTERLACED. If not set it is progressive. Refer define_detailed_timing_flags. + int iScanType; +/// Refresh rate. + int iRefreshRate; +/// Timing Standard. Refer define_modetiming_standard. + int iTimingStandard; +} ADLDisplayModeX2; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about Overdrive 6 extension capabilities +/// +/// This structure is used to store information about Overdrive 6 extension capabilities +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct _ADLOD6CapabilitiesEx +{ + /// Contains a bitmap of the OD6 extension capability flags. Possible values: \ref ADL_OD6_CAPABILITY_SCLK_CUSTOMIZATION, + /// \ref ADL_OD6_CAPABILITY_MCLK_CUSTOMIZATION, \ref ADL_OD6_CAPABILITY_GPU_ACTIVITY_MONITOR, + /// \ref ADL_OD6_CAPABILITY_POWER_CONTROL, \ref ADL_OD6_CAPABILITY_VOLTAGE_CONTROL, \ref ADL_OD6_CAPABILITY_PERCENT_ADJUSTMENT, + //// \ref ADL_OD6_CAPABILITY_THERMAL_LIMIT_UNLOCK + int iCapabilities; + /// The Power states that support clock and power customization. Only performance state is currently supported. + /// Possible Values: \ref ADL_OD6_SUPPORTEDSTATE_PERFORMANCE + int iSupportedStates; + /// Returns the hard limits of the SCLK overdrive adjustment range. Overdrive clocks should not be adjusted outside of this range. The values are specified as +/- percentages. + ADLOD6ParameterRange sEngineClockPercent; + /// Returns the hard limits of the MCLK overdrive adjustment range. Overdrive clocks should not be adjusted outside of this range. The values are specified as +/- percentages. + ADLOD6ParameterRange sMemoryClockPercent; + /// Returns the hard limits of the Power Limit adjustment range. Power limit should not be adjusted outside this range. The values are specified as +/- percentages. + ADLOD6ParameterRange sPowerControlPercent; + /// Reserved for future expansion of the structure. + int iExtValue; + /// Reserved for future expansion of the structure. + int iExtMask; +} ADLOD6CapabilitiesEx; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about Overdrive 6 extension state information +/// +/// This structure is used to store information about Overdrive 6 extension state information +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct _ADLOD6StateEx +{ + /// The current engine clock adjustment value, specified as a +/- percent. + int iEngineClockPercent; + /// The current memory clock adjustment value, specified as a +/- percent. + int iMemoryClockPercent; + /// The current power control adjustment value, specified as a +/- percent. + int iPowerControlPercent; + /// Reserved for future expansion of the structure. + int iExtValue; + /// Reserved for future expansion of the structure. + int iExtMask; +} ADLOD6StateEx; + +///////////////////////////////////////////////////////////////////////////////////////////// +///\brief Structure containing information about Overdrive 6 extension recommended maximum clock adjustment values +/// +/// This structure is used to store information about Overdrive 6 extension recommended maximum clock adjustment values +/// \nosubgrouping +//////////////////////////////////////////////////////////////////////////////////////////// +typedef struct _ADLOD6MaxClockAdjust +{ + /// The recommended maximum engine clock adjustment in percent, for the specified power limit value. + int iEngineClockMax; + /// The recommended maximum memory clock adjustment in percent, for the specified power limit value. + /// Currently the memory is independent of the Power Limit setting, so iMemoryClockMax will always return the maximum + /// possible adjustment value. This field is here for future enhancement in case we add a dependency between Memory Clock + /// adjustment and Power Limit setting. + int iMemoryClockMax; + /// Reserved for future expansion of the structure. + int iExtValue; + /// Reserved for future expansion of the structure. + int iExtMask; +} ADLOD6MaxClockAdjust; + +#endif /* ADL_STRUCTURES_H_ */ + diff --git a/renderdoc/driver/ihv/amd/official/RGP/Common/DriverToolsDefinitions.h b/renderdoc/driver/ihv/amd/official/RGP/Common/DriverToolsDefinitions.h new file mode 100644 index 000000000..8a411b777 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/Common/DriverToolsDefinitions.h @@ -0,0 +1,66 @@ +//============================================================================= +/// Copyright (c) 2017 Advanced Micro Devices, Inc. All rights reserved. +/// \author AMD Developer Tools Team +/// \file +/// \brief Shared definitions for the Developer Driver components. +//============================================================================= + +#ifndef _DRIVER_TOOLS_DEFINITIONS_H_ +#define _DRIVER_TOOLS_DEFINITIONS_H_ + +#include "Version.h" +#include "../DevDriverComponents/inc/gpuopen.h" +#include "../DevDriverComponents/inc/ddPlatform.h" + +#ifdef WIN32 +#include +#endif + +#ifdef _DEBUG + #define SHOW_DEBUG_WINDOW 1 +#endif + +#define SAFE_DELETE(x) {if(x){delete (x); (x) = nullptr; }} +#define SAFE_DELETE_ARRAY(x) {if(x){delete [] (x); x = nullptr; }} + +#ifdef HEADLESS +#define HEADLESS_FILENAME_SUFFIX "CLI" +#else +#define HEADLESS_FILENAME_SUFFIX "" +#endif // HEADLESS + +#define BUILD_FILENAME_SUFFIX "" + +static const char* gs_RDP_SETTINGS_DIRECTORY = "RadeonDeveloperDriver"; ///< RDP and RDS use this directory to write settings to. +static const char* gs_RGP_EXECUTABLE_FILENAME = "RadeonGPUProfiler" BUILD_FILENAME_SUFFIX; ///< RGP's executable filename. +static const char* gs_RDP_EXECUTABLE_FILENAME = "RadeonDeveloperPanel" BUILD_FILENAME_SUFFIX; ///< RDP's executable filename. +static const char* gs_RDP_APPLICATION_GUID = "C9EB0587-F8F7-4B8C-B35A-F7C2862CFDA7"; ///< Unique identifier for the RDP application +static const char* gs_RDS_EXECUTABLE_FILENAME = "RadeonDeveloperService" HEADLESS_FILENAME_SUFFIX BUILD_FILENAME_SUFFIX; ///< RDS's executable filename. +static const char* gs_RDS_APPLICATION_GUID = "D0939873-BA4B-4C4E-9729-D82DED85BC41"; ///< Unique identifier for the RDS service +static const char* gs_RGP_TRACE_EXTENSION = ".rgp"; ///< The extension used when saving RGP trace files. + +// Help for Command line options +#ifdef WIN32 +static const char* gs_RDS_CLI_USAGE_DESCRIPTION = " [--help] | [--port ] | [--enableUWP]\n\n"; +#else +static const char* gs_RDS_CLI_USAGE_DESCRIPTION = " [--help] | [--port ]\n\n"; +#endif // WIN32 +static const char* gs_RDS_CLI_HELP_OPTION_DESCRIPTION = "--help This help message."; ///< Command line help for --help +static const char* gs_RDS_CLI_PORT_OPTION_DESCRIPTION = "--port The listener port. Where is a value between 1 and 65535."; ///< Command line help for --port +static const char* gs_RDS_CLI_UWPENABLE_OPTION_DESCRIPTION = "--enableUWP Enable UWP support."; ///< Command line help for --enableUWP + +// Default RDS connection info. +static const char* gs_DEFAULT_HOST_ADDRESS = "0.0.0.0"; ///< The default address to listen on for incoming connections. +static const unsigned int gs_DEFAULT_CONNECTION_PORT = 27300; ///< The default port used to connect the Developer Panel to the Developer Service. +static const unsigned short gs_MAX_LISTEN_PORT = 65535; ///< The highest port that the Developer Service can listen on. + +// Control window sizes. +static const int gs_DESKTOP_MARGIN = 25; +static const int gs_OS_TITLE_BAR_HEIGHT = 35; +static const float gs_DESKTOP_AVAIL_WIDTH_PCT = 99.0f; +static const float gs_DESKTOP_AVAIL_HEIGHT_PCT = 95.0f; +static const float gs_MAIN_WINDOW_DESKTOP_WIDTH_PCT = 100.0f; +static const float gs_MAIN_WINDOW_DESKTOP_HEIGHT_PCT = 85.0f; +static const float gs_DBG_WINDOW_DESKTOP_WIDTH_PCT = 35.0f; + +#endif // _DRIVER_TOOLS_DEFINITIONS_H_ diff --git a/renderdoc/driver/ihv/amd/official/RGP/Common/Version.h b/renderdoc/driver/ihv/amd/official/RGP/Common/Version.h new file mode 100644 index 000000000..08313d2f1 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/Common/Version.h @@ -0,0 +1,32 @@ +//============================================================================= +/// Copyright (c) 2017 Advanced Micro Devices, Inc. All rights reserved. +/// \author AMD Developer Tools Team +/// \file +/// \brief Version number info for the Developer Driver tools. +//============================================================================= + +#ifndef _VERSION_H_ +#define _VERSION_H_ + +#define STRINGIFY_VALUE(x) STRINGIFY(x) +#define STRINGIFY(x) #x + +#define DEV_DRIVER_TOOLS_MAJOR_VERSION 1 ///< Major version number. +#define DEV_DRIVER_TOOLS_MINOR_VERSION 2 ///< Minor version number. +#define DEV_DRIVER_TOOLS_BUGFIX_NUMBER 0 ///< Bugfix number. +#define DEV_DRIVER_TOOLS_BUILD_NUMBER 0 ///< Build number. + +#ifdef HEADLESS +#define DEV_DRIVER_TOOLS_BUILD_SUFFIX "- CLI" ///< The build suffix to apply to the product name for headess build. +#else +#define DEV_DRIVER_TOOLS_BUILD_SUFFIX "" ///< The build suffix to apply to the product name. +#endif // HEADLESS + +#define DEV_DRIVER_TOOLS_BUILD_DATE_STRING "4/10/2018" ///< Build date string. + +#define DEV_DRIVER_TOOLS_VERSION_STRING STRINGIFY_VALUE(DEV_DRIVER_TOOLS_MAJOR_VERSION) "." \ + STRINGIFY_VALUE(DEV_DRIVER_TOOLS_MINOR_VERSION) "." \ + STRINGIFY_VALUE(DEV_DRIVER_TOOLS_BUGFIX_NUMBER) "." \ + STRINGIFY_VALUE(DEV_DRIVER_TOOLS_BUILD_NUMBER) ///< The full revision string. + +#endif // _VERSION_H_ diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverAPI/ADLGetDriverVersion.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverAPI/ADLGetDriverVersion.cpp new file mode 100644 index 000000000..20978e799 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverAPI/ADLGetDriverVersion.cpp @@ -0,0 +1,218 @@ +//============================================================================= +/// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved. +/// \author AMD Developer Tools Team +/// \file +/// \brief Retrieve driver version information for AMD Radeon Drivers on Windows using ADL +//============================================================================= + +// To compile from the windows CMD prompt into a standalone command-line executable for test +// - use the following commands with Visual Studio 2017 +// +// > "c:\Program Files (x86)\Microsoft Visual Studio 14.0\Common7\Tools\vsvars32.bat" +// > cl ADLGetDriverVersion.cpp -I -D COMMAND_LINE_TEST /EHsc + +#ifdef _WIN32 +#include +#include +#include "adl_sdk.h" + +#include "ADLGetDriverVersion.h" + +/// Structure used to query driver version info +typedef struct ADLVersionsInfo +{ + /// Driver Release (Packaging) Version (e.g. 8.71-100128n-094835E-ATI) + char strDriverVer[ADL_MAX_PATH]; + /// Catalyst Version(e.g. "10.1"). + char strCatalystVersion[ADL_MAX_PATH]; + /// Web link to an XML file with information about the latest AMD drivers and locations (e.g. "http://www.amd.com/us/driverxml" ) + char strCatalystWebLink[ADL_MAX_PATH]; + +} ADLVersionsInfo, *LPADLVersionsInfo; + +// Definitions of the used ADL function pointers. +typedef int(*ADL2_MAIN_CONTROL_CREATE)(ADL_MAIN_MALLOC_CALLBACK, int, ADL_CONTEXT_HANDLE*); +typedef int(*ADL2_MAIN_CONTROL_DESTROY)(ADL_CONTEXT_HANDLE); +typedef int(*ADL2_GRAPHICS_VERSION_GET)(ADL_CONTEXT_HANDLE context, ADLVersionsInfo * lpVersionsInfo); + +// Memory allocation function for use with ADL +static void* __stdcall ADL_Main_Memory_Alloc(int iSize) +{ + void* lpBuffer = malloc(iSize); + return lpBuffer; +} + +//----------------------------------------------------------------------------- +/// Parse version string returned by the driver via ADL to extract version info +/// \param versionString The string returned from the driver via ADL +/// \param major The major version number +/// \param minor The minor version number +/// \param subminor The subminor version number +/// \return true if successful, or false on error +//----------------------------------------------------------------------------- +static bool parseDriverVersionString(char *versionString, unsigned int &major, unsigned int &minor, unsigned int &subminor) +{ + major = minor = subminor = 0; + std::string strDriverVersion(versionString); + +#ifdef COMMAND_LINE_TEST + printf("\nVersion string from driver: %s\n", versionString); +#endif + + // driver version looks like: 13.35.1005-140131a-167669E-ATI or 14.10-140115n-021649E-ATI, etc... + // truncate at the first dash + strDriverVersion = strDriverVersion.substr(0, strDriverVersion.find("-", 0)); + + size_t pos = 0; + std::string strToken; + std::string strDelimiter = "."; + std::stringstream ss; + + // parse the major driver version (start of string to first ".") + pos = strDriverVersion.find(strDelimiter); + + if (pos == std::string::npos) + { + // delimiter not found + return false; + } + + strToken = strDriverVersion.substr(0, pos); + ss.str(strToken); + + if ((ss >> major).fail()) + { + major = 0; + return false; + } + + strDriverVersion.erase(0, pos + strDelimiter.length()); // Delete section of string already parsed + + // parse the minor driver version + bool subminorAvailable = false; + + pos = strDriverVersion.find(strDelimiter); + + if (pos != std::string::npos) + { + // Delimiter found + strToken = strDriverVersion.substr(0, pos); + strDriverVersion.erase(0, pos + strDelimiter.length()); + subminorAvailable = true; + } + else + { + // No delimeter - use entire string + strToken = strDriverVersion; + } + + ss.clear(); + ss.str(strToken); + + if ((ss >> minor).fail()) + { + major = 0; + minor = 0; + return false; + } + + // parse the sub-minor driver version + if (subminorAvailable) + { + pos = strDriverVersion.find(strDelimiter); + + if (pos != std::string::npos) + { + // Delimiter found + strToken = strDriverVersion.substr(0, pos); + } + else + { + strToken = strDriverVersion; + } + ss.clear(); + ss.str(strToken); + + if ((ss >> subminor).fail()) + { + major = 0; + minor = 0; + subminor = 0; + return false; + } + } + return true; +} + +//----------------------------------------------------------------------------- +/// Use ADL on Windows to retrieve the driver version number +/// \param majorVar The major version number +/// \param minorVer The minor version number +/// \param subminorVer The subminor version number +/// \return true if successful, or false on error +//----------------------------------------------------------------------------- +bool ADLGetDriverVersion(unsigned int& majorVer, unsigned int& minorVer, unsigned int& subminorVer) +{ + bool retStatus = false; + + HINSTANCE hDLL = LoadLibrary(TEXT("atiadlxx.dll")); + + if (NULL == hDLL) + { + // A 32 bit calling application on 64 bit OS will fail to LoadLIbrary. + // Try to load the 32 bit library (atiadlxy.dll) instead + hDLL = LoadLibrary(TEXT("atiadlxy.dll")); + } + + if (NULL != hDLL) + { + ADL2_MAIN_CONTROL_CREATE ADL2_Main_Control_Create = (ADL2_MAIN_CONTROL_CREATE)GetProcAddress(hDLL, "ADL2_Main_Control_Create");; + ADL2_MAIN_CONTROL_DESTROY ADL2_Main_Control_Destroy = (ADL2_MAIN_CONTROL_DESTROY)GetProcAddress(hDLL, "ADL2_Main_Control_Destroy"); + ADL2_GRAPHICS_VERSION_GET ADL2_Graphics_Versions_Get = (ADL2_GRAPHICS_VERSION_GET)GetProcAddress(hDLL, "ADL2_Graphics_Versions_Get"); + + if (NULL != ADL2_Main_Control_Create && + NULL != ADL2_Main_Control_Destroy && + NULL != ADL2_Graphics_Versions_Get + ) + { + ADL_CONTEXT_HANDLE adlContext = NULL; + if (ADL_OK == ADL2_Main_Control_Create(ADL_Main_Memory_Alloc, 1, &adlContext)) + { + ADLVersionsInfo versionsInfo; + int ADLResult = ADL2_Graphics_Versions_Get(adlContext, &versionsInfo); + if (ADL_OK == ADLResult || ADL_OK_WARNING == ADLResult) + { + retStatus = parseDriverVersionString(versionsInfo.strDriverVer, majorVer, minorVer, subminorVer); + } + ADL2_Main_Control_Destroy(adlContext); + } + } + FreeLibrary(hDLL); + } + return retStatus; +} + +#endif // _WIN32 + +#ifdef COMMAND_LINE_TEST +int main() +{ + unsigned int major, minor, subminor; + + if (ADLGetDriverVersion(major, minor, subminor) == true) + { + printf("\nDriver Major Version: %d", major); + printf("\nDriver Minor Version: %d", minor); + if (subminor != 0) + { + printf("\nDriver SubMinor Version: %d", subminor); + } + } + else + { + printf("\nUnable to retrieve driver version information"); + } + printf("\n"); + +} +#endif diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverAPI/ADLGetDriverVersion.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverAPI/ADLGetDriverVersion.h new file mode 100644 index 000000000..e2af360e9 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverAPI/ADLGetDriverVersion.h @@ -0,0 +1,21 @@ +//============================================================================= +/// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved. +/// \author AMD Developer Tools Team +/// \file +/// \brief Retrieve driver version information for AMD Radeon Drivers on Windows using ADL +//============================================================================= +#ifndef ADL_GET_DRIVER_VERSION_H_ +#define ADL_GET_DRIVER_VERSION_H_ + +#ifdef _WIN32 +//----------------------------------------------------------------------------- +/// Use ADL on Windows to retrieve the driver version number +/// \param majorVar The major version number +/// \param minorVer The minor version number +/// \param subminorVer The subminor version number +/// \return true if successful, or false on error +//----------------------------------------------------------------------------- +bool ADLGetDriverVersion(unsigned int& majorVer, unsigned int& minorVer, unsigned int& subminorVer); +#endif // _WIN32 + +#endif // ADL_GET_DRIVER_VERSION_H_ diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverAPI/DevDriverAPI.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverAPI/DevDriverAPI.cpp new file mode 100644 index 000000000..33c769d30 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverAPI/DevDriverAPI.cpp @@ -0,0 +1,345 @@ +//============================================================================= +/// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved. +/// \author AMD Developer Tools Team +/// \file +/// \brief An API for the developer mode driver to initialize driver protocols. +/// Can be used by applications to take RGP profiles of themselves +//============================================================================= + +#ifdef _WIN32 +#include "ADLGetDriverVersion.h" +#else +#include +#include +#include +#endif + +#include + +#include "DevDriverAPI.h" +#include "RGPClientInProcessModel.h" + +// C wrapper functions + +//----------------------------------------------------------------------------- +/// Initialization function. To be called before initializing the device. +/// \param featureList An array of DevDriverFeatures structures containing +/// a list of features to be enabled +/// \param featureCount The number of features in the list +/// \param pOutHandle A returned handle to the DevDriverAPI context. +/// \return DEV_DRIVER_STATUS_SUCCESS if successful, or a DevDriverStatus error +/// code if not. If this function fails, pOutHandle will be unchanged. +//----------------------------------------------------------------------------- +static DevDriverStatus DEV_DRIVER_API_CALL +Init(const DevDriverFeatures featureList[], uint32_t featureCount, DevDriverAPIContext* pOutHandle) +{ + bool rgpEnabled = false; + + for (uint32_t loop = 0; loop < featureCount; loop++) + { + DevDriverFeature feature = featureList[loop].m_option; + switch (feature) + { + case DEV_DRIVER_FEATURE_ENABLE_RGP: + rgpEnabled = true; + break; + + default: + break; + } + } + + RGPClientInProcessModel* pHandle = new(std::nothrow) RGPClientInProcessModel(); + + if (pHandle != nullptr) + { + if (pHandle->Init(rgpEnabled) == true) + { + *pOutHandle = reinterpret_cast(pHandle); + return DEV_DRIVER_STATUS_SUCCESS; + } + else + { + delete pHandle; + return DEV_DRIVER_STATUS_FAILED; + } + } + else + { + return DEV_DRIVER_STATUS_BAD_ALLOC; + } +} + +//----------------------------------------------------------------------------- +/// Cleanup function. To be called at application shutdown. +/// \param context The DevDriverAPI context +/// \return DEV_DRIVER_STATUS_SUCCESS if successful, or a DevDriverStatus error +/// code if not. +//----------------------------------------------------------------------------- +static DevDriverStatus DEV_DRIVER_API_CALL +Finish(DevDriverAPIContext handle) +{ + if (handle != nullptr) + { + RGPClientInProcessModel* pObj = reinterpret_cast(handle); + pObj->Finish(); + delete pObj; + return DEV_DRIVER_STATUS_SUCCESS; + } + else + { + return DEV_DRIVER_STATUS_NULL_POINTER; + } +} + +//----------------------------------------------------------------------------- +/// Start triggering a profile. The actual profiling is done in a separate thread. +/// The calling function will need to call IsRGPProfileCaptured() to determine +/// if the profile has finished. +/// \param context The DevDriverAPI context +/// \param profileOptions A structure of type RGPProfileOptions containing the +/// profile options +/// \return DEV_DRIVER_STATUS_SUCCESS if a capture was successfully started, or +/// a DevDriverStatus error code if not. +//----------------------------------------------------------------------------- +static DevDriverStatus DEV_DRIVER_API_CALL +TriggerCapture(DevDriverAPIContext handle, const RGPProfileOptions* const profileOptions) +{ + if (handle != nullptr) + { + RGPClientInProcessModel* pObj = reinterpret_cast(handle); + bool requestingFrameTerminators = pObj->SetTriggerMarkerParams(profileOptions->m_beginFrameTerminatorTag, profileOptions->m_endFrameTerminatorTag, + profileOptions->m_pBeginFrameTerminatorString, profileOptions->m_pEndFrameTerminatorString); + + bool captureAllowed = pObj->IsCaptureAllowed(requestingFrameTerminators); + if (captureAllowed == false) + { + return DEV_DRIVER_STATUS_INVALID_PARAMETERS; + } + + bool triggered = pObj->TriggerCapture(profileOptions->m_pProfileFilePath); + if (triggered == true) + { + return DEV_DRIVER_STATUS_SUCCESS; + } + else + { + return DEV_DRIVER_STATUS_CAPTURE_FAILED; + } + } + else + { + return DEV_DRIVER_STATUS_NULL_POINTER; + } +} + +//----------------------------------------------------------------------------- +/// Has an RGP profile been taken? +/// \param context The DevDriverAPI context +/// \return DEV_DRIVER_STATUS_SUCCESS if successful, or a DevDriverStatus error +/// code if not. +//----------------------------------------------------------------------------- +static DevDriverStatus DEV_DRIVER_API_CALL +IsProfileCaptured(DevDriverAPIContext handle) +{ + if (handle != nullptr) + { + bool captured = reinterpret_cast(handle)->IsProfileCaptured(); + if (captured == true) + { + return DEV_DRIVER_STATUS_SUCCESS; + } + else + { + return DEV_DRIVER_STATUS_NOT_CAPTURED; + } + } + else + { + return DEV_DRIVER_STATUS_NULL_POINTER; + } +} + +//----------------------------------------------------------------------------- +/// Get the name of the last captured RGP profile. Call this after taking a +/// profile. +/// \param context The DevDriverAPI context +/// \return DEV_DRIVER_STATUS_SUCCESS if successful, or a DevDriverStatus error +/// code if not. +//----------------------------------------------------------------------------- +static DevDriverStatus DEV_DRIVER_API_CALL +GetProfileName(DevDriverAPIContext handle, const char** ppOutProfileName) +{ + if (handle != nullptr) + { + const char* pProfileName = reinterpret_cast(handle)->GetProfileName(); + *ppOutProfileName = pProfileName; + return DEV_DRIVER_STATUS_SUCCESS; + } + else + { + return DEV_DRIVER_STATUS_NULL_POINTER; + } +} + +#ifndef _WIN32 +//----------------------------------------------------------------------------- +/// Convert a string to an int. Continue parsing the string until an non-digit +/// is found. +/// \param pString Reference to a pointer to a string to parse. The new value +/// of the pointer is modified in the calling function +/// \return The integer value found in the string. If no integer value is found +/// 0 is returned. +//----------------------------------------------------------------------------- +static unsigned int ToInt(const char* &pString) +{ + unsigned int value = 0; + while (*pString >= '0' && *pString <= '9') + { + value *= 10; + value += *pString++ - '0'; + } + return value; +} +#endif + +//----------------------------------------------------------------------------- +/// Get the video driver version number. +/// indirectly returns the major and minor version numbers in the parameters +/// \param outMajorVersion The major version number returned +/// \param outMinorVersion The minor version number returned +/// \return DEV_DRIVER_STATUS_SUCCESS if successful, or a DevDriverStatus error +/// code if not. If an error is returned, the version nunbers passed in are +/// unmodified. +//----------------------------------------------------------------------------- +static DevDriverStatus DEV_DRIVER_API_CALL +GetDriverVersion(DevDriverAPIContext handle, unsigned int& outMajorVersion, unsigned int& outMinorVersion) +{ + if (handle == nullptr) + { + return DEV_DRIVER_STATUS_NULL_POINTER; + } + + bool result = false; + unsigned int subMinorVer = 0; +#ifdef _WIN32 + result = ADLGetDriverVersion(outMajorVersion, outMinorVersion, subMinorVer); +#else + const int sysret = system("modinfo amdgpu | grep version > version.txt"); + if (sysret != 0) + { + return DEV_DRIVER_STATUS_ERROR; + } + + std::string lineString; + std::ifstream inFile; + const char* versionFile = "version.txt"; + inFile.open(versionFile); + if (inFile.is_open()) + { + do + { + getline(inFile, lineString); + size_t pos = 0; + const char* searchString = "version:"; + const size_t searchStringLength = strlen(searchString); + + // look for all instances of the search string and only consider ones which are longer than + // the search string. These strings should have a version number on the end. The complete version + // string should look something like: + // version: 18.10.0.1 + pos = lineString.find(searchString, pos); + if (pos == 0) + { + const char* pVersion = lineString.c_str(); + pVersion += searchStringLength; + + // skip spaces + while (*pVersion == ' ') + { + pVersion++; + } + + int majVer = 0; + int minVer = 0; + + // get the major version number + majVer = ToInt(pVersion); + + DD_ASSERT(pVersion[0] == '.'); + + // skip the delimiter + pVersion++; + + // get the minor version + minVer = ToInt(pVersion); + + outMajorVersion = majVer; + outMinorVersion = minVer; + result = true; + } + } + while (lineString.length() > 0 && result == false); + inFile.close(); + } + + // remove the file + remove(versionFile); + +#endif + + if (result == true) + { + return DEV_DRIVER_STATUS_SUCCESS; + } + else + { + return DEV_DRIVER_STATUS_ERROR; + } +} + +//----------------------------------------------------------------------------- +/// Get the function table +/// \param pAprTableOut Pointer to an array to receive the list of function +/// pointers. Should be initialized to be at least the size of a DevDriverAPI +/// structure. +/// \return DEV_DRIVER_STATUS_SUCCESS if successful, or a DevDriverStatus error +/// code if not. +//----------------------------------------------------------------------------- +DEV_DRIVER_API_EXPORT DevDriverStatus DEV_DRIVER_API_CALL +DevDriverGetFuncTable(void* pApiTableOut) +{ + if (pApiTableOut == nullptr) + { + return DEV_DRIVER_STATUS_NULL_POINTER; + } + + DevDriverAPI* pApiTable = reinterpret_cast(pApiTableOut); + + if (pApiTable->majorVersion != DEV_DRIVER_API_MAJOR_VERSION) + { + // only support the exact major version match for now + return DEV_DRIVER_STATUS_INVALID_MAJOR_VERSION; + } + + uint32_t suppliedMinorVersion = pApiTable->minorVersion; + + // build the dispatch table containing all supported functions in this library + DevDriverAPI apiTable; + + apiTable.majorVersion = DEV_DRIVER_API_MAJOR_VERSION; + apiTable.minorVersion = std::min(suppliedMinorVersion, DEV_DRIVER_API_MINOR_VERSION); + + apiTable.DevDriverInit = Init; + apiTable.DevDriverFinish = Finish; + + apiTable.TriggerRgpProfile = TriggerCapture; + apiTable.IsRgpProfileCaptured = IsProfileCaptured; + apiTable.GetRgpProfileName = GetProfileName; + + apiTable.GetDriverVersion = GetDriverVersion; + + // only copy the functions supported by the incoming requested library + memcpy(pApiTable, &apiTable, apiTable.minorVersion); + return DEV_DRIVER_STATUS_SUCCESS; +} diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverAPI/DevDriverAPI.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverAPI/DevDriverAPI.h new file mode 100644 index 000000000..746dc323e --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverAPI/DevDriverAPI.h @@ -0,0 +1,170 @@ +//============================================================================= +/// Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved. +/// \author AMD Developer Tools Team +/// \file +/// \brief An API for the developer mode driver to initialize driver protocols. +/// Can be used by applications to take RGP profiles of themselves +//============================================================================= +#ifndef DEV_DRIVER_API_H_ +#define DEV_DRIVER_API_H_ + +#include + +#if defined(_WIN32) || defined(__CYGWIN__) + /// The API calling convention on windows. + #define DEV_DRIVER_API_CALL __cdecl + #ifdef BUILD_DLL + #define DEV_DRIVER_API_EXPORT __declspec(dllexport) + #elif defined(IMPORT_DLL) + #define DEV_DRIVER_API_EXPORT __declspec(dllimport) + #else + #define DEV_DRIVER_API_EXPORT + #endif // BUILD_DLL +#else + /// The API calling convention on linux. + #define DEV_DRIVER_API_CALL + #define DEV_DRIVER_API_EXPORT +#endif + +#define DEV_DRIVER_API_MAJOR_VERSION 1 +#define DEV_DRIVER_API_MINOR_VERSION (sizeof(DevDriverAPI)) + +#ifdef __cplusplus +extern "C" { +#endif // #ifdef __cplusplus + +typedef void* DevDriverAPIContext; + +// An enum of status codes returned from the API +typedef enum +{ + DEV_DRIVER_STATUS_SUCCESS = 0, + DEV_DRIVER_STATUS_ERROR = -1, + DEV_DRIVER_STATUS_FAILED = -2, + DEV_DRIVER_STATUS_NULL_POINTER = -3, + DEV_DRIVER_STATUS_BAD_ALLOC = -4, + DEV_DRIVER_STATUS_CAPTURE_FAILED = -5, + DEV_DRIVER_STATUS_NOT_CAPTURED = -6, + DEV_DRIVER_STATUS_INVALID_MAJOR_VERSION = -7, + DEV_DRIVER_STATUS_INVALID_PARAMETERS = -8, +} DevDriverStatus; + +// An enum of options to pass into the DevDriverAPI +typedef enum +{ + DEV_DRIVER_FEATURE_ENABLE_RGP = 1, +} DevDriverFeature; + +// structure containing any features relating to RGP +typedef struct DevDriverFeatureRGP +{ + // presently nothing needed for RGP initialization + uint32_t reserved; ///< ensure a specific size struct for C/C++ +} DevDriverFeatureRGP; + +// structure containing a developer driver feature. Specific +// feature structures can be added to the union as needed +typedef struct DevDriverFeatures +{ + DevDriverFeature m_option; + uint32_t m_size; + union + { + DevDriverFeatureRGP m_featureRGP; + }; +} DevDriverFeatures; + +// structure containing any options required for taking an RGP profile +typedef struct RGPProfileOptions +{ + const char* m_pProfileFilePath; ///< The file (and path) used to save the captured profile to. If the + ///< path is omitted, the file will be saved to the default folder. + ///< If nullptr is specified, then a filename will be generated based + ///< on the process name and a date/time timestamp + + // frame terminator values + uint64_t m_beginFrameTerminatorTag; ///< frame terminator begin tag (vulkan). Should be non-zero if being used + uint64_t m_endFrameTerminatorTag; ///< frame terminator end tag (vulkan). Should be non-zero if being used + const char* m_pBeginFrameTerminatorString; ///< frame terminator begin string (D3D12). Should be non-null/non-empty if being used + const char* m_pEndFrameTerminatorString; ///< frame terminator end string (D3D12). Should be non-null/non-empty if being used +} RGPProfileOptions; + +// function typedefs + +/// Initialization function. To be called before initializing the device. +/// \param featureList An array of DevDriverFeatures structures containing +/// a list of features to be enabled +/// \param featureCount The number of features in the list +/// \param pOutHandle A returned handle to the DevDriverAPI context. +/// \return DEV_DRIVER_STATUS_SUCCESS if successful, or a DevDriverStatus error +/// code if not. If this function fails, pOutHandle will be unchanged. +typedef DevDriverStatus(DEV_DRIVER_API_CALL* + DevDriverFnInit)(const DevDriverFeatures featureList[], uint32_t featureCount, DevDriverAPIContext* pOutHandle); + +/// Cleanup function. To be called at application shutdown. +/// \param context The DevDriverAPI context +/// \return DEV_DRIVER_STATUS_SUCCESS if successful, or a DevDriverStatus error +/// code if not. +typedef DevDriverStatus(DEV_DRIVER_API_CALL* + DevDriverFnFinish)(DevDriverAPIContext context); + +/// Start triggering a profile. The actual profiling is done in a separate thread. +/// The calling function will need to call IsRGPProfileCaptured() to determine +/// if the profile has finished. +/// \param context The DevDriverAPI context +/// \param profileOptions A structure of type RGPProfileOptions containing the +/// profile options +/// \return DEV_DRIVER_STATUS_SUCCESS if a capture was successfully started, or +/// a DevDriverStatus error code if not. +typedef DevDriverStatus(DEV_DRIVER_API_CALL* + DevDriverFnTriggerRGPProfile)(DevDriverAPIContext context, const RGPProfileOptions* const profileOptions); + +/// Has an RGP profile been taken? +/// \param context The DevDriverAPI context +/// \return DEV_DRIVER_STATUS_SUCCESS if successful, or a DevDriverStatus error +/// code if not. +typedef DevDriverStatus(DEV_DRIVER_API_CALL* + DevDriverFnIsRGPProfileCaptured)(DevDriverAPIContext context); + +/// Get the name of the last captured RGP profile. Call this after taking a +/// profile. +/// \param context The DevDriverAPI context +/// \return DEV_DRIVER_STATUS_SUCCESS if successful, or a DevDriverStatus error +/// code if not. +typedef DevDriverStatus(DEV_DRIVER_API_CALL* + DevDriverFnGetRGPProfileName)(DevDriverAPIContext context, const char** ppOutProfileName); + +/// Get the video driver version number. +/// indirectly returns the major and minor version numbers in the parameters +/// \param outMajorVersion The major version number returned +/// \param outMinorVersion The minor version number returned +/// \return DEV_DRIVER_STATUS_SUCCESS if successful, or a DevDriverStatus error +/// code if not. If an error is returned, the version nunbers passed in are +/// unmodified. +typedef DevDriverStatus(DEV_DRIVER_API_CALL* + DevDriverFnGetDriverVersion)(DevDriverAPIContext context, unsigned int& outMajorVersion, unsigned int& outMinorVersion); + +// structure containing the list of functions supported by this version of the API. +// Also contains major and minor version numbers +typedef struct DevDriverAPI +{ + uint32_t majorVersion; + uint32_t minorVersion; + + DevDriverFnInit DevDriverInit; + DevDriverFnFinish DevDriverFinish; + + DevDriverFnTriggerRGPProfile TriggerRgpProfile; + DevDriverFnIsRGPProfileCaptured IsRgpProfileCaptured; + DevDriverFnGetRGPProfileName GetRgpProfileName; + DevDriverFnGetDriverVersion GetDriverVersion; +} DevDriverAPI; + +/// Get the function table +DEV_DRIVER_API_EXPORT DevDriverStatus DEV_DRIVER_API_CALL DevDriverGetFuncTable(void* pApiTableOut); + +#ifdef __cplusplus +} +#endif // #ifdef __cplusplus + +#endif // DEV_DRIVER_API_H_ diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverAPI/RGPClientInProcessModel.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverAPI/RGPClientInProcessModel.cpp new file mode 100644 index 000000000..ec2adff19 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverAPI/RGPClientInProcessModel.cpp @@ -0,0 +1,835 @@ +//============================================================================= +/// Copyright (c) 2017 Advanced Micro Devices, Inc. All rights reserved. +/// \author AMD Developer Tools Team +/// \file +/// \brief a class to provide service to initialize dev driver protocols to +/// capture rgp trace from within the profiled application. +//============================================================================= +#include +#include +#include +#include +#include "RGPClientInProcessModel.h" + +#include +#include + +#include + +#include "../../Common/DriverToolsDefinitions.h" + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#ifdef _LINUX +int sprintf_s(char* _DstBuf, size_t _SizeInBytes, const char* _Format, ...) +{ + int retVal; + va_list arg_ptr; + + va_start(arg_ptr, _Format); + retVal = vsnprintf(_DstBuf, _SizeInBytes, _Format, arg_ptr); + va_end(arg_ptr); + return retVal; +} + +char* strncpy_s(char* _DstBuf, const char* _SrcBuf, size_t num) +{ + return strncpy(_DstBuf, _SrcBuf, num); +} +#endif + +void* GenericAlloc(void* pUserdata, size_t size, size_t alignment, bool zero) +{ + DD_UNUSED(pUserdata); + + return DevDriver::Platform::AllocateMemory(size, alignment, zero); +} + +void GenericFree(void* pUserdata, void* pMemory) +{ + DD_UNUSED(pUserdata); + + DevDriver::Platform::FreeMemory(pMemory); +} + +DevDriver::AllocCb GenericAllocCb = +{ + nullptr, + &GenericAlloc, + &GenericFree +}; + +void DbgMsg(const std::string& strMsg) +{ +#ifdef _DEBUG + std::cout << strMsg << std::endl; + char buf[1024]; + sprintf_s(buf, 1024, "%s\n", strMsg.c_str()); + #ifdef _LINUX + printf(buf); + #else + OutputDebugStringA(buf); + #endif +#else + DD_UNUSED(strMsg); +#endif // def _DEBUG +} + +// Worker thread states +enum WorkerThreadState +{ + STATE_INIT, + STATE_CAPTURING, + STATE_IDLE, + STATE_FINISHED, + STATE_DONE, +}; + +// The global worker thread state +static std::atomic g_workerState(STATE_INIT); + +// The global worker thread mutex +static std::mutex g_workerThreadMutex; + +RGPClientInProcessModel::RGPClientInProcessModel() : + m_pClient(nullptr), + m_profileCaptured(false), + m_finished(false), + m_requestingShutdown(false), + m_beginTag(0), + m_endTag(0) +{ + m_beginMarker.clear(); + m_endMarker.clear(); +} + +RGPClientInProcessModel::~RGPClientInProcessModel() +{ + Finish(); +} + +bool RGPClientInProcessModel::Init(bool rgpEnabled) +{ + InitDriverProtocols(); + if (rgpEnabled) + { + CreateWorkerThreadToResumeDriverAndCollectRgpTrace(); + } + + return true; +} + +void RGPClientInProcessModel::Finish() +{ + m_requestingShutdown = true; + if (m_finished == false) + { + g_workerThreadMutex.lock(); + while (g_workerState != STATE_DONE) + { + g_workerThreadMutex.unlock(); + DevDriver::Platform::Sleep(10); + g_workerThreadMutex.lock(); + if (g_workerState == STATE_IDLE) + { + g_workerState = STATE_FINISHED; + } + } + g_workerThreadMutex.unlock(); + DeInitDriverProtocols(); + m_finished = true; + } +} + +bool RGPClientInProcessModel::InitDriverProtocols() +{ + DevDriver::ListenerCreateInfo createInfo = {}; + const char* kListenerDescription = "Radeon Developer Service [RGPClientInProcess]"; + DevDriver::Platform::Strncpy(createInfo.description, kListenerDescription, sizeof(createInfo.description)); + createInfo.flags.enableServer = 1; + createInfo.serverCreateInfo.enabledProtocols.etw = true; + + createInfo.allocCb = GenericAllocCb; + + DevDriver::Result result = m_listenerCore.Initialize(createInfo); + if (DevDriver::Result::Success != result) + { + DbgMsg("Failed to initialize listener core"); + return false; + } + DbgMsg("Listener core initialized successfully"); + + DevDriver::DevDriverClientCreateInfo clientCreateInfo = {}; + clientCreateInfo.transportCreateInfo.type = DevDriver::TransportType::Local; + + DevDriver::Platform::Strncpy(clientCreateInfo.transportCreateInfo.clientDescription, "RGPClientInProcess", sizeof(clientCreateInfo.transportCreateInfo.clientDescription)); + + clientCreateInfo.transportCreateInfo.componentType = DevDriver::Component::Tool; + + clientCreateInfo.transportCreateInfo.createUpdateThread = true; + clientCreateInfo.transportCreateInfo.initialFlags = static_cast(DevDriver::ClientStatusFlags::DeveloperModeEnabled) | + static_cast(DevDriver::ClientStatusFlags::HaltOnConnect); + + clientCreateInfo.transportCreateInfo.allocCb = createInfo.allocCb; + + m_pClient = new(std::nothrow) DevDriver::DevDriverClient(clientCreateInfo); + if (nullptr == m_pClient) + { + DbgMsg("Failed to allocate memory for client"); + return false; + } + + DevDriver::Result initResult = m_pClient->Initialize(); + if (DevDriver::Result::Success != initResult) + { + DbgMsg("Failed to initialize client"); + return false; + } + DbgMsg("Client initialized successfully"); + + return true; +} + +void RGPClientInProcessModel::DeInitDriverProtocols() +{ +#if 1 + if (m_thread.Join() != DevDriver::Result::Success) + { + DbgMsg("Failed to join rgp client thread"); + } +#endif + + if (m_pClient != nullptr) + { + m_pClient->Destroy(); + delete m_pClient; + m_pClient = nullptr; + } + + m_listenerCore.Destroy(); +} + +//----------------------------------------------------------------------------- +/// Generate the name of the profile to be saved. This is obtained from the +/// process name and a generated time stamp, in much the same way that the +/// panel does things. +/// \param profileName A string to accept the generated profile name string +//----------------------------------------------------------------------------- +void RGPClientInProcessModel::GenerateProfileName(std::string& profileName) +{ + char processName[1024]; + DevDriver::Platform::GetProcessName(&processName[0], sizeof(processName)); + + // calculate the timestamp as yyyymmdd-hhmmss + const int BUFFER_SIZE = 32; + char timeStamp[BUFFER_SIZE]; + + time_t t = time(nullptr); + tm* timePtr = localtime(&t); + sprintf_s(timeStamp, BUFFER_SIZE, "-%04d%02d%02d-%02d%02d%02d", timePtr->tm_year + 1900, timePtr->tm_mon + 1, timePtr->tm_mday, timePtr->tm_hour, timePtr->tm_min, timePtr->tm_sec); + + // build the filename, consisting of exe name, timestamp and rgp extension. Rip off the '.exe' from the executable name if it exists + std::string delimiter = ".exe"; + size_t pos = 0; + std::string executableName = processName; + + if ((pos = executableName.find(delimiter)) != std::string::npos) + { + executableName = executableName.substr(0, pos); + } + + profileName = executableName + timeStamp + gs_RGP_TRACE_EXTENSION; +} + +//----------------------------------------------------------------------------- +/// Set the GPU clock mode to be used when collecting an RGP trace. +/// \returns Result::Success if the clock mode was set correctly, and an error code if it failed. +//----------------------------------------------------------------------------- +DevDriver::Result RGPClientInProcessModel::SetGPUClockMode( + DevDriver::DriverControlProtocol::DriverControlClient* pDriverControlClient, + DevDriver::DriverControlProtocol::DeviceClockMode kTraceClockMode) +{ + using namespace DevDriver; + + Result setClockResult = Result::Error; + + if (pDriverControlClient != nullptr && pDriverControlClient->IsConnected()) + { + // RDP explicitly sets the GPU's clock mode to ensure timing accuracy while collecting a trace. + static const int kGPUIndex = 0; + setClockResult = pDriverControlClient->SetDeviceClockMode(kGPUIndex, kTraceClockMode); + if (setClockResult == Result::Success) + { + DbgMsg("Set/Reset clock mode for profiling."); + } + } + else + { + DbgMsg("Didn't set/reset clock for profiling because DriverControlClient wasn't connected."); + } + + if (setClockResult != Result::Success) + { + DbgMsg("Failed to set/reset GPU clocks for profiling."); + } + + return setClockResult; +} + +struct RGPTraceContext +{ + std::ofstream* pRgpFile; + DevDriver::uint64 numChunks; ///< The number of chunks received for the trace file. + size_t totalTraceSizeInBytes; ///< The final total size of the RGP trace file in bytes. +}; + +void RGPChunkFunc(const DevDriver::RGPProtocol::TraceDataChunk* pChunk, void* pUserdata) +{ + RGPTraceContext* pTraceContext = reinterpret_cast(pUserdata); + std::ofstream* pRgpFile = pTraceContext->pRgpFile; + + pRgpFile->write(reinterpret_cast(pChunk->data), pChunk->dataSize); + + pTraceContext->numChunks++; + pTraceContext->totalTraceSizeInBytes += pChunk->dataSize; +} + +bool RGPClientInProcessModel::CollectRgpTrace( + DevDriver::RGPProtocol::RGPClient* pRgpClient, + DevDriver::DriverControlProtocol::DriverControlClient* pDriverControlClient, + const RGPProfileParameters& profileParameters) +{ + using namespace DevDriver; + + std::ofstream rgpFile; + RGPTraceContext clientTraceContext = {}; + clientTraceContext.pRgpFile = &rgpFile; + + DevDriver::RGPProtocol::BeginTraceInfo traceInfo = {}; + traceInfo.callbackInfo.chunkCallback = &RGPChunkFunc; + traceInfo.callbackInfo.pUserdata = &clientTraceContext; + traceInfo.parameters.numPreparationFrames = 4; + traceInfo.parameters.flags.enableInstructionTokens = false; + traceInfo.parameters.flags.allowComputePresents = false; + +#ifdef GPUOPEN_SESSION_INTERFACE_CLEANUP_VERSION + traceInfo.parameters.beginTag = profileParameters.beginTag; + traceInfo.parameters.endTag = profileParameters.endTag; + if (profileParameters.pBeginMarker != nullptr) + { + DevDriver::Platform::Strncpy(traceInfo.parameters.beginMarker, profileParameters.pBeginMarker, sizeof(traceInfo.parameters.beginMarker)); + } + if (profileParameters.pEndMarker) + { + DevDriver::Platform::Strncpy(traceInfo.parameters.endMarker, profileParameters.pEndMarker, sizeof(traceInfo.parameters.endMarker)); + } +#endif + + // Set the GPU clock mode before starting a trace. + Result setClocks = SetGPUClockMode(pDriverControlClient, DevDriver::DriverControlProtocol::DeviceClockMode::Peak); + + Result requestResult = pRgpClient->BeginTrace(traceInfo); + + Result restoredClocks = Result::Error; + + if (requestResult == Result::Success) + { + DbgMsg("Profiling began successfully."); + + uint32 numChunks = 0; + uint64 traceSizeInBytes = 0; + + requestResult = pRgpClient->EndTrace(&numChunks, &traceSizeInBytes); + + // Revert the clock mode to the RDP default after tracing. + if (setClocks == Result::Success) + { + restoredClocks = SetGPUClockMode(pDriverControlClient, DevDriver::DriverControlProtocol::DeviceClockMode::Default); + } + + if (requestResult == Result::Success || requestResult == Result::Unavailable) + { + // Only try to write the trace file if the trace executed correctly. + if (m_profileName.empty()) + { + GenerateProfileName(m_profileName); + } + rgpFile.open(m_profileName.c_str(), std::ios::out | std::ios::binary); + + // Read chunks until we hit the end of the stream. + do + { + requestResult = pRgpClient->ReadTraceDataChunk(); + } while (requestResult == Result::Success); + + if (requestResult == Result::EndOfStream) + { + // If the result is EndOfStream, it means that all of the trace chunks were transferred. + // Just return Success to better indicate that the trace was successful. + requestResult = Result::Success; + + if (rgpFile.is_open()) + { + rgpFile.close(); + } + DbgMsg("RGP trace file captured."); + SetProfileCaptured(true); + } + } + + return true; + } + else + { + DbgMsg("Failed to begin profile"); + + // Looks like tracing failed- Attempt to revert the clock state to what it was originally. + restoredClocks = SetGPUClockMode(pDriverControlClient, DevDriver::DriverControlProtocol::DeviceClockMode::Default); + if (restoredClocks != Result::Success) + { + DbgMsg("Failed to restore GPU clocks to default after profiling."); + } + + return false; + } +} + +bool RGPClientInProcessModel::ConnectProtocolClients( + DevDriver::DevDriverClient* pClient, + DevDriver::ClientId clientId, + DevDriver::RGPProtocol::RGPClient*& pRgpClientOut, + DevDriver::DriverControlProtocol::DriverControlClient*& pDriverControlClientOut) +{ + using namespace DevDriver; + using namespace RGPProtocol; + using namespace DriverControlProtocol; + + bool bReturn = true; + + // Connect Driver Control Client + pDriverControlClientOut = pClient->AcquireProtocolClient(); + if (nullptr == pDriverControlClientOut) + { + DbgMsg("Driver control client not available"); + bReturn = false; + } + else + { + DbgMsg("Driver control client is available"); + } + + if (pDriverControlClientOut->Connect(clientId) != Result::Success) + { + DbgMsg("Failed to connect DriverControlClient"); + bReturn = false; + } + else + { + DbgMsg("Driver control client is connected"); + } + + // Connect RGP Client + pRgpClientOut = pClient->AcquireProtocolClient(); + if (nullptr == pRgpClientOut) + { + DbgMsg("RGP client not available"); + bReturn = false; + } + else + { + DbgMsg("RGP client is available"); + } + + if (pRgpClientOut->Connect(clientId) != DevDriver::Result::Success) + { + DbgMsg("Failed to connect rgp client"); + bReturn = false; + } + else + { + DbgMsg("RGP client connected"); + } + + return bReturn; +} + +void RGPClientInProcessModel::DisconnectProtocolClients( + DevDriver::DevDriverClient* pClient, + DevDriver::RGPProtocol::RGPClient* pRgpClient, + DevDriver::DriverControlProtocol::DriverControlClient* pDriverControlClient) +{ + if (pClient == nullptr) + { + return; + } + + if (pRgpClient != nullptr && pRgpClient->IsConnected()) + { + pRgpClient->Disconnect(); + pClient->ReleaseProtocolClient(pRgpClient); + } + + if (pDriverControlClient != nullptr && pDriverControlClient->IsConnected()) + { + pDriverControlClient->Disconnect(); + pClient->ReleaseProtocolClient(pDriverControlClient); + } +} + +bool RGPClientInProcessModel::EnableRgpProfiling(DevDriver::RGPProtocol::RGPClient* pRgpClient) +{ + using namespace DevDriver; + using namespace RGPProtocol; + + // Make sure profiling status starts as Available + ProfilingStatus profilingStatus = ProfilingStatus::NotAvailable; + if (pRgpClient->QueryProfilingStatus(&profilingStatus) != Result::Success) + { + DbgMsg("Failed to query rgp profiling status on client"); + } + else + { + DbgMsg("Successfull to query rgp profiling status on client"); + } + + if (profilingStatus != ProfilingStatus::Available) + { + DbgMsg("RGP profiling status is not available"); + } + else + { + DbgMsg("RGP profiling status is available"); + } + + Result result = pRgpClient->EnableProfiling(); + + if (result == Result::Success) + { + DbgMsg("RGP profiling enabled"); + return true; + } + else + { + DbgMsg("Failed to enable RGP profiling"); + return false; + } +} + +bool RGPClientInProcessModel::ResumeDriverAndWaitForDriverInitilization(DevDriver::DriverControlProtocol::DriverControlClient* pDriverControlClient) +{ + using namespace DevDriver; + bool bReturn = true; + + if (pDriverControlClient->ResumeDriver() != Result::Success) + { + DbgMsg("Failed to resume driver"); + bReturn = false; + } + else + { + DbgMsg("Driver resumed"); + } + + DbgMsg("Waiting for driver initialization on client"); + Result result = pDriverControlClient->WaitForDriverInitialization(8000); + if (result == Result::Success) + { + DbgMsg("Wait for driver initialization successful on client"); + } + else if (result == Result::Unavailable) + { + DbgMsg("Wait for driver initialization not available on client"); + bReturn = false; + } + else if (result == Result::NotReady) + { + DbgMsg("Wait for driver initialization timed out on client"); + bReturn = false; + } + else + { + DbgMsg("Wait for driver initialization failed on client\n"); + bReturn = false; + } + + return bReturn; +} + +bool ProcessHaltedMessage(RGPClientInProcessModel* pContext, DevDriver::ClientId clientId) +{ + return pContext->ProcessHaltedMessage(clientId); +} + +bool RGPClientInProcessModel::ProcessHaltedMessage(DevDriver::ClientId clientId) +{ + if (m_pClient->IsConnected()) + { + bool resumed = false; + + using namespace DevDriver; + using namespace RGPProtocol; + using namespace DriverControlProtocol; + + RGPClient* pRgpClient = nullptr; + DriverControlClient* pDriverControlClient = nullptr; + + ConnectProtocolClients(m_pClient, clientId, pRgpClient, pDriverControlClient); + m_clientId = clientId; + + if (pRgpClient != nullptr) + { + EnableRgpProfiling(pRgpClient); + } + + if (pDriverControlClient != nullptr) + { + resumed = ResumeDriverAndWaitForDriverInitilization(pDriverControlClient); + } + DisconnectProtocolClients(m_pClient, pRgpClient, pDriverControlClient); + + return resumed; + } + return false; +} + +//----------------------------------------------------------------------------- +/// Validate if a capture is possible. Checks various capture parameters and +/// sees if the requested capture features are enabled in the driver or +/// interface. +/// If the user requests a particular feature and that feature isn't available +/// then a capture isn't possible since it doesn't do exactly what the user +/// wants, even though it may be possible to perform a capture without the +/// requested feature. +/// \param requestingFrameTerminators Is the user requesting frame terminators +/// \return true if a capture is possible, false otherwise +//----------------------------------------------------------------------------- +bool RGPClientInProcessModel::IsCaptureAllowed(bool requestingFrameTerminators) +{ + using namespace DevDriver; + using namespace RGPProtocol; + using namespace DriverControlProtocol; + + RGPClient* pRgpClient = nullptr; + DriverControlClient* pDriverControlClient = nullptr; + + ConnectProtocolClients(m_pClient, m_clientId, pRgpClient, pDriverControlClient); + + bool userMarkerVersion = false; + + // check the protocol trigger marker version. Need to fail if the user has chosen to use + // trigger markers but the DevDriverTools don't support it +#ifdef RGP_TRIGGER_MARKERS_VERSION + if (pRgpClient->GetSessionVersion() >= RGP_TRIGGER_MARKERS_VERSION) + { + userMarkerVersion = true; + } +#endif + + DisconnectProtocolClients(m_pClient, pRgpClient, pDriverControlClient); + + if (requestingFrameTerminators == true && userMarkerVersion == false) + { + return false; + } + + return true; +} + +//----------------------------------------------------------------------------- +/// Collect a trace. This function is run in the worker thread to do the +/// actual frame capture. +//----------------------------------------------------------------------------- +void RGPClientInProcessModel::CollectTrace() +{ + using namespace DevDriver; + using namespace RGPProtocol; + using namespace DriverControlProtocol; + + RGPClient* pRgpClient = nullptr; + DriverControlClient* pDriverControlClient = nullptr; + + ConnectProtocolClients(m_pClient, m_clientId, pRgpClient, pDriverControlClient); + + if (pRgpClient != nullptr && pDriverControlClient != nullptr) + { + RGPProfileParameters profileParameters = {}; + profileParameters.beginTag = m_beginTag; + profileParameters.endTag = m_endTag; + profileParameters.pBeginMarker = m_beginMarker.c_str(); + profileParameters.pEndMarker = m_endMarker.c_str(); + CollectRgpTrace(pRgpClient, pDriverControlClient, profileParameters); + } + + DisconnectProtocolClients(m_pClient, pRgpClient, pDriverControlClient); +} + +//----------------------------------------------------------------------------- +/// Worker thread to wait until the driver halted message has been received +/// and resume the application +//----------------------------------------------------------------------------- +static void WorkerInit(void* pThreadParam) +{ + bool result = false; + using namespace DevDriver; + RGPWorkerThreadContext* pThreadContext = reinterpret_cast(pThreadParam); + RGPClientInProcessModel* pContext = pThreadContext->m_pContext; + DevDriverClient* pClient = pThreadContext->m_pClient; + + MessageBuffer message = {}; + IMsgChannel* pMsgChannel = pClient->GetMessageChannel(); + const uint32 kLogDelayInMs = 100; + + while (pMsgChannel->IsConnected() && result == false && pContext->IsRequestingShutdown() == false) + { + DevDriver::Result status = pMsgChannel->Receive(message, kLogDelayInMs); + while (status == DevDriver::Result::Success && !pContext->IsProfileCaptured()) + { + if (message.header.protocolId == Protocol::System) + { + using namespace SystemProtocol; + DevDriver::SystemProtocol::SystemMessage msg = static_cast(message.header.messageId); + switch (msg) + { + case SystemMessage::Halted: + result = ProcessHaltedMessage(pContext, message.header.srcClientId); + break; + default: + break; + } + } + status = pMsgChannel->Receive(message, 0); + } + } + g_workerThreadMutex.lock(); + g_workerState = STATE_IDLE; + g_workerThreadMutex.unlock(); +} + +static void WorkerCapture(void* pThreadParam) +{ + using namespace DevDriver; + RGPWorkerThreadContext* pThreadContext = reinterpret_cast(pThreadParam); + RGPClientInProcessModel* pContext = pThreadContext->m_pContext; + + pContext->CollectTrace(); + g_workerThreadMutex.lock(); + g_workerState = STATE_IDLE; + g_workerThreadMutex.unlock(); +} + +// Worker thread function. This is set up at init time, and WorkerInit is called then. Once a capture is triggered, +// the WorkerCapture() function is called +void RGPWorkerThreadFunc(void* pThreadParam) +{ + g_workerThreadMutex.lock(); + WorkerThreadState state = g_workerState; + g_workerThreadMutex.unlock(); + + while (state != STATE_FINISHED) + { + switch (state) + { + case STATE_INIT: + WorkerInit(pThreadParam); + break; + + case STATE_CAPTURING: + WorkerCapture(pThreadParam); + break; + + default: + break; + } + g_workerThreadMutex.lock(); + state = g_workerState; + g_workerThreadMutex.unlock(); + } + g_workerThreadMutex.lock(); + g_workerState = STATE_DONE; + g_workerThreadMutex.unlock(); +} + +bool RGPClientInProcessModel::SetTriggerMarkerParams(uint64_t beginTag, uint64_t endTag, const char* beginMarker, const char* endMarker) +{ + bool requestingFrameTerminators = false; + + if (beginTag != 0 && endTag != 0) + { + m_beginTag = beginTag; + m_endTag = endTag; + requestingFrameTerminators = true; + } + if (beginMarker != nullptr && endMarker != nullptr) + { + m_beginMarker = beginMarker; + m_endMarker = endMarker; + requestingFrameTerminators = true; + } + return requestingFrameTerminators; +} + +bool RGPClientInProcessModel::TriggerCapture(const char* pszCaptureFileName) +{ + g_workerThreadMutex.lock(); + if (g_workerState == STATE_IDLE) + { + g_workerState = STATE_CAPTURING; + g_workerThreadMutex.unlock(); + SetProfileCaptured(false); + m_profileName = ""; + if (pszCaptureFileName != nullptr) + { + m_profileName = pszCaptureFileName; + } + return true; + } + g_workerThreadMutex.unlock(); + return false; +} + +bool RGPClientInProcessModel::CreateWorkerThreadToResumeDriverAndCollectRgpTrace() +{ + m_threadContext.m_pContext = this; + m_threadContext.m_pClient = m_pClient; + + // reset the initial state + g_workerThreadMutex.lock(); + g_workerState = STATE_INIT; + g_workerThreadMutex.unlock(); + + if (m_thread.Start(RGPWorkerThreadFunc, (void *)&m_threadContext) != DevDriver::Result::Success) + { + DbgMsg("Failed to create rgp worker thread"); + return false; + } + DbgMsg("Successfull to create rgp worker thread"); + + if (!m_thread.IsJoinable()) + { + DbgMsg("Rgp worker thread is not joinable"); + return false; + } + +#if 0 + if (m_thread.Join() != DevDriver::Result::Success) + { + DbgMsg("Failed to join rgp worker thread"); + } +#endif + + return true; +} diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverAPI/RGPClientInProcessModel.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverAPI/RGPClientInProcessModel.h new file mode 100644 index 000000000..0afc6f052 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverAPI/RGPClientInProcessModel.h @@ -0,0 +1,108 @@ +//============================================================================= +/// Copyright (c) 2017 Advanced Micro Devices, Inc. All rights reserved. +/// \author AMD Developer Tools Team +/// \file +/// \brief a class to provide service to initialize dev driver protocols to +/// capture rgp trace from within the profiled application. +//============================================================================= +#ifndef RGP_CLIENT_IN_PROCESS_MODEL_H_ +#define RGP_CLIENT_IN_PROCESS_MODEL_H_ + +#include <../listener/listenerCore.h> +#include +#include +#include + +class RGPClientInProcessModel; + +typedef struct +{ + RGPClientInProcessModel* m_pContext; + DevDriver::DevDriverClient* m_pClient; +} RGPWorkerThreadContext; + +struct RGPProfileParameters +{ + uint64_t beginTag; + uint64_t endTag; + const char* pBeginMarker; + const char* pEndMarker; +}; + +class RGPClientInProcessModel +{ +public: + RGPClientInProcessModel(); + ~RGPClientInProcessModel(); + + bool Init(bool rgpEnabled); + void Finish(); + + bool IsProfileCaptured() const { return m_profileCaptured; } + bool IsRequestingShutdown() const { return m_requestingShutdown; } + const char* GetProfileName() const { return m_profileName.c_str(); } + + bool SetTriggerMarkerParams(uint64_t beginTag, uint64_t endTag, const char* beginMarker, const char* endMarker); + + bool TriggerCapture(const char* pszCaptureFileName); + bool IsCaptureAllowed(bool requestingFrameTerminators); + void CollectTrace(); + + bool ProcessHaltedMessage(DevDriver::ClientId clientId); + +private: + RGPClientInProcessModel(const RGPClientInProcessModel& c); // disable + RGPClientInProcessModel& operator=(const RGPClientInProcessModel& c); // disable + + bool InitDriverProtocols(); + void DeInitDriverProtocols(); + + bool CreateWorkerThreadToResumeDriverAndCollectRgpTrace(); + + void GenerateProfileName(std::string& profileName); + void SetProfileCaptured(bool bCaptured) { m_profileCaptured = bCaptured; } + + bool ConnectProtocolClients( + DevDriver::DevDriverClient* pClient, + DevDriver::ClientId clientId, + DevDriver::RGPProtocol::RGPClient*& pRgpClientOut, + DevDriver::DriverControlProtocol::DriverControlClient*& pDriverControlClientOut); + + void DisconnectProtocolClients( + DevDriver::DevDriverClient* pClient, + DevDriver::RGPProtocol::RGPClient* pRgpClient, + DevDriver::DriverControlProtocol::DriverControlClient* pDriverControlClient); + + DevDriver::Result SetGPUClockMode( + DevDriver::DriverControlProtocol::DriverControlClient* pDriverControlClient, + DevDriver::DriverControlProtocol::DeviceClockMode kTraceClockMode); + + bool EnableRgpProfiling(DevDriver::RGPProtocol::RGPClient* pRgpClient); + + bool ResumeDriverAndWaitForDriverInitilization(DevDriver::DriverControlProtocol::DriverControlClient* pDriverControlClient); + + bool CollectRgpTrace( + DevDriver::RGPProtocol::RGPClient* pRgpClient, + DevDriver::DriverControlProtocol::DriverControlClient* pDriverControlClient, + const RGPProfileParameters& profileParameters); + + DevDriver::ListenerCore m_listenerCore; + DevDriver::DevDriverClient* m_pClient; + + DevDriver::Platform::Thread m_thread; + RGPWorkerThreadContext m_threadContext; + + std::string m_profileName; ///< The name of the last saved profile + + DevDriver::ClientId m_clientId; ///< The current client Id + bool m_profileCaptured; ///< Has a profile been captured + bool m_finished; ///< Has Finished() been called. Ensure it's only called once + std::atomic m_requestingShutdown; ///< The application is requesting shutdown, so exit worker thread loops + + uint64_t m_beginTag; ///< The begin tag name + uint64_t m_endTag; ///< The end tag name + std::string m_beginMarker; ///< The begin marker name + std::string m_endMarker; ///< The end marker name +}; + +#endif // RGP_CLIENT_IN_PROCESS_MODEL_H_ diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/baseProtocolClient.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/baseProtocolClient.h new file mode 100644 index 000000000..9993b938c --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/baseProtocolClient.h @@ -0,0 +1,211 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file baseProtocolClient.h +* @brief Class declaration for BaseProtocolClient. +*********************************************************************************************************************** +*/ + +#pragma once + +#include "protocolClient.h" + +namespace DevDriver +{ + class IMsgChannel; + + enum class ClientState : uint32 + { + Disconnected = 0, + Connecting, + Connected + }; + + class BaseProtocolClient : public IProtocolClient + { + public: + virtual ~BaseProtocolClient(); + + // query constant properties of the protocol client + Protocol GetProtocol() const override final { return m_protocol; }; + SessionType GetType() const override final { return SessionType::Client; }; + Version GetMinVersion() const override final { return m_minVersion; }; + Version GetMaxVersion() const override final { return m_maxVersion; }; + + // connection management/tracking + Result Connect(ClientId clientId) override final; + void Disconnect() override final; + bool IsConnected() const override final; + +#if !DD_VERSION_SUPPORTS(GPUOPEN_SESSION_INTERFACE_CLEANUP_VERSION) + // Orphans the current session associated with the client object and moves to the disconnected state + void Orphan() override final; +#endif + + // properties that are only valid in a connected session + ClientId GetRemoteClientId() const override final; + Version GetSessionVersion() const override final; + + // asychronous callbacks used by the SessionManager - should never be called directly + virtual void SessionEstablished(const SharedPointer& pSession) override; + virtual void UpdateSession(const SharedPointer& pSession) override; + virtual void SessionTerminated(const SharedPointer& pSession, Result terminationReason) override; + + protected: + BaseProtocolClient(IMsgChannel* pMsgChannel, Protocol protocol, Version minVersion, Version maxVersion); + + // Default implementation of ResetState that does nothing + virtual void ResetState() {}; + + IMsgChannel* const m_pMsgChannel; + const Protocol m_protocol; + const Version m_minVersion; + const Version m_maxVersion; + + SharedPointer m_pSession; + + DD_STATIC_CONST uint32 kDefaultRetryTimeoutInMs = 50; + DD_STATIC_CONST uint32 kDefaultCommunicationTimeoutInMs = 5000; + + // Attempts to receive a payload into a fixed size buffer. + // Returns the result and the size of the payload if it was received successfully. + Result ReceiveSizedPayload(void* pPayloadBuffer, + uint32 payloadBufferSize, + uint32* pBytesReceived, + uint32 timeoutInMs = kDefaultCommunicationTimeoutInMs, + uint32 retryInMs = kDefaultRetryTimeoutInMs) + { + uint32 timeElapsed = 0; + // Blocking wait on the message. + Result result = Result::Error; + + SharedPointer pSession = m_pSession; + if (!pSession.IsNull()) + { + do + { + result = pSession->Receive(payloadBufferSize, pPayloadBuffer, pBytesReceived, retryInMs); + timeElapsed += retryInMs; + } + while ((result == Result::NotReady) & (timeElapsed <= timeoutInMs)); + } + + return result; + } + + // Templated wrapper around ReceiveSizedPayload + template + Result ReceivePayload(T& payload, + uint32 timeoutInMs = kDefaultCommunicationTimeoutInMs, + uint32 retryInMs = kDefaultRetryTimeoutInMs) + { + uint32 bytesReceived = 0; + Result result = ReceiveSizedPayload(&payload, sizeof(T), &bytesReceived, timeoutInMs, retryInMs); + + // Return an error if we don't get back the size we were expecting. + if ((result == Result::Success) & (bytesReceived != sizeof(T))) + { + result = Result::Error; + } + + return result; + } + + // Attempts to send a payload + Result SendSizedPayload(const void* pPayload, + uint32 payloadSize, + uint32 timeoutInMs = kDefaultCommunicationTimeoutInMs, + uint32 retryInMs = kDefaultRetryTimeoutInMs) + { + Result result = Result::Error; + uint32 timeElapsed = 0; + SharedPointer pSession = m_pSession; + if (!pSession.IsNull()) + { + do + { + result = pSession->Send(payloadSize, pPayload, retryInMs); + timeElapsed += retryInMs; + } while ((result == Result::NotReady) & (timeElapsed <= timeoutInMs)); + } + return result; + } + + // Templated wrapper around SendSizedPayload + template + Result SendPayload(T& payload, + uint32 timeoutInMs = kDefaultCommunicationTimeoutInMs, + uint32 retryInMs = kDefaultRetryTimeoutInMs) + { + return SendSizedPayload(&payload, sizeof(T), timeoutInMs, retryInMs); + } + + // Attempts to perform a payload "transaction" which is defined as sending one payload out, and receiving one in response. + Result TransactSized(const void* pSendPayload, + uint32 sendSize, + void* pReceivePayload, + uint32 receiveSize, + uint32* pBytesReceived, + uint32 timeoutInMs = kDefaultCommunicationTimeoutInMs, + uint32 retryInMs = kDefaultRetryTimeoutInMs) + { + Result result = Result::Error; + if (IsConnected()) + { + result = SendSizedPayload(pSendPayload, sendSize, timeoutInMs, retryInMs); + if (result == Result::Success) + { + result = ReceiveSizedPayload(pReceivePayload, receiveSize, pBytesReceived, timeoutInMs, retryInMs); + } + } + return result; + } + + // Templated wrapper around TransactSized + template + Result Transact(const T& sendPayload, + U& receivePayload, + uint32 timeoutInMs = kDefaultCommunicationTimeoutInMs, + uint32 retryInMs = kDefaultRetryTimeoutInMs) + { + Result result = Result::Error; + if (IsConnected()) + { + result = SendPayload(sendPayload, timeoutInMs, retryInMs); + if (result == Result::Success) + { + result = ReceivePayload(receivePayload, timeoutInMs, retryInMs); + } + } + return result; + } + + private: + Platform::Event m_pendingOperationEvent; + Result m_connectResult; + ClientState m_state; + }; + +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/baseProtocolServer.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/baseProtocolServer.h new file mode 100644 index 000000000..eb4eacab5 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/baseProtocolServer.h @@ -0,0 +1,67 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file baseProtocolServer.h +* @brief Class declaration for BaseProtocolServer. +*********************************************************************************************************************** +*/ + +#pragma once + +#include "protocolServer.h" + +namespace DevDriver +{ + class IMsgChannel; + + class BaseProtocolServer : public IProtocolServer + { + public: + virtual ~BaseProtocolServer(); + + Protocol GetProtocol() const override final { return m_protocol; }; + SessionType GetType() const override final { return SessionType::Server; }; + Version GetMinVersion() const override final { return m_minVersion; }; + Version GetMaxVersion() const override final { return m_maxVersion; }; + + bool GetSupportedVersion(Version minVersion, Version maxVersion, Version * version) const override final; + + virtual void Finalize() override; + protected: + BaseProtocolServer(IMsgChannel* pMsgChannel, Protocol protocol, Version minVersion, Version maxVersion); + + // Helper functions for working with SizedPayloadContainers + Result SendPayload(ISession* pSession, const SizedPayloadContainer* pPayload, uint32 timeoutInMs); + Result ReceivePayload(ISession* pSession, SizedPayloadContainer* pPayload, uint32 timeoutInMs); + + IMsgChannel* const m_pMsgChannel; + const Protocol m_protocol; + const Version m_minVersion; + const Version m_maxVersion; + + bool m_isFinalized; + }; + +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/ddPlatform.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/ddPlatform.h new file mode 100644 index 000000000..47b702f27 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/ddPlatform.h @@ -0,0 +1,328 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file platform.h +* @brief GPUOpen Platform Abstraction Layer +*********************************************************************************************************************** +*/ + +#pragma once + +#include "gpuopen.h" + +#if !defined(NDEBUG) +#if !defined(DEVDRIVER_FORCE_ASSERT) +#define DEVDRIVER_FORCE_ASSERT +#endif +#if !defined(DEVDRIVER_HARD_ASSERT) +#define DEVDRIVER_HARD_ASSERT +#endif +#endif + +#if defined(_WIN32) +#include "win/ddWinPlatform.h" +#elif defined(__APPLE__) || defined(__linux__) +#include "posix/ddPosixPlatform.h" +#endif + +#if defined(__x86_64__) || defined(_M_X64) +#define DD_ARCH_STRING "x86-64" +#elif defined(__i386__) || defined(_M_IX86) +#define DD_ARCH_STRING "x86" +#else +#define DD_ARCH_STRING "Unk" +#endif + +#if defined(DD_WINDOWS) +#define DD_OS_STRING "Windows" +#elif defined(DD_LINUX) +#define DD_OS_STRING "Linux" +#else +#define DD_OS_STRING "Unknown" +#endif + +#include "util/template.h" +#include "util/memory.h" +#include + +// TODO: remove this and make kDebugLogLevel DD_STATIC_CONST when we use a version of visual studio that supports it +#ifdef DEVDRIVER_LOG_LEVEL + #define DEVDRIVER_LOG_LEVEL_VALUE static_cast(DEVDRIVER_LOG_LEVEL) +#else + #if defined(NDEBUG) + #define DEVDRIVER_LOG_LEVEL_VALUE LogLevel::Always + #else + #define DEVDRIVER_LOG_LEVEL_VALUE LogLevel::Verbose + #endif +#endif + +#define DD_WILL_PRINT(lvl) ((lvl >= DEVDRIVER_LOG_LEVEL_VALUE) & (lvl < DevDriver::LogLevel::Count)) +#define DD_PRINT(lvl, ...) DevDriver::LogString(__VA_ARGS__) + +#if !defined(DEVDRIVER_FORCE_ASSERT) + +#define DD_ALERT(statement) (DD_UNUSED(0)) +#define DD_ASSERT(statement) (DD_UNUSED(0)) +#define DD_ASSERT_REASON(reason) (DD_UNUSED(0)) +#define DD_ALERT_REASON(reason) (DD_UNUSED(0)) + +#else + +#define DD_STRINGIFY(str) #str +#define DD_STRINGIFY_(x) DD_STRINGIFY(x) +#define DD_ALERT(statement) \ +{ \ + if (!(statement)) \ + { \ + DD_PRINT(DevDriver::LogLevel::Alert, "%s (%d): Alert triggered in %s: %s\n", \ + __FILE__, __LINE__, __func__, DD_STRINGIFY(statement)); \ + } \ +} + +#define DD_ASSERT(statement) \ +{ \ + if (!(statement)) \ + { \ + DD_PRINT(DevDriver::LogLevel::Error, "%s (%d): Assertion failed in %s: %s\n", \ + __FILE__, __LINE__, __func__, DD_STRINGIFY(statement)); \ + DevDriver::Platform::DebugBreak(__FILE__, __LINE__, __func__, DD_STRINGIFY(statement)); \ + } \ +} + +#define DD_ALERT_REASON(reason) \ +{ \ + DD_PRINT(DevDriver::LogLevel::Alert, "%s (%d): Alert triggered in %s: %s\n", \ + __FILE__, __LINE__, __func__, reason); \ +} + +#define DD_ASSERT_REASON(reason) \ +{ \ + DD_PRINT(DevDriver::LogLevel::Error, "%s (%d): Assertion failed in %s: %s\n", \ + __FILE__, __LINE__, __func__, reason); \ + DevDriver::Platform::DebugBreak(__FILE__, __LINE__, __func__, reason); \ +} + +#endif + +#if !defined(DD_RESTRICT) +#define DD_RESTRICT +#endif + +/// Convenience macro that always asserts. +#define DD_ASSERT_ALWAYS() DD_ASSERT_REASON("Unconditional Assert") + +/// Convenience macro that always alerts. +#define DD_ALERT_ALWAYS() DD_ALERT_REASON("Unconditional Alert") + +/// Convenience macro that asserts if something has not been implemented. +#define DD_NOT_IMPLEMENTED() DD_ASSERT_REASON("Code not implemented!") + +/// Convenience macro that asserts if an area of code that shouldn't be executed is reached. +#define DD_UNREACHABLE() DD_ASSERT_REASON("Unreachable code has been reached!") + +namespace DevDriver +{ + namespace Platform + { + + void DebugPrint(LogLevel lvl, const char* format, ...); + + /* platform functions for performing atomic operations */ + + int32 AtomicIncrement(Atomic *variable); + int32 AtomicDecrement(Atomic *variable); + int32 AtomicAdd(Atomic *variable, int32 num); + int32 AtomicSubtract(Atomic *variable, int32 num); + + class Thread + { + public: + Thread(); + ~Thread(); + Result Start(void(*threadCallback)(void *), void *threadParameter); + Result Join(); + bool IsJoinable() const; + + private: + ThreadStorage m_thread; + }; + + void* AllocateMemory(size_t size, size_t alignment, bool zero); + void FreeMemory(void* pMemory); + + /* fast locks */ + class AtomicLock + { + public: + AtomicLock() : m_lock(0) {}; + ~AtomicLock() {}; + void Lock(); + void Unlock(); + bool IsLocked() { return m_lock != 0; }; + private: + Atomic m_lock; + }; + + class Mutex + { + public: + Mutex(); + ~Mutex(); + void Lock(); + void Unlock(); + private: + MutexStorage m_mutex; + }; + + class Semaphore + { + public: + explicit Semaphore(uint32 initialCount, uint32 maxCount); + ~Semaphore(); + Result Signal(); + Result Wait(uint32 millisecTimeout); + private: + SemaphoreStorage m_semaphore; + }; + + class Event + { + public: + explicit Event(bool signaled); + ~Event(); + void Clear(); + void Signal(); + Result Wait(uint32 timeoutInMs); + private: + EventStorage m_event; + }; + + class Random + { + public: + Random(); + ~Random(); + uint32 Generate(); + static uint32 Max(); + + private: + RandomStorage m_randState; + }; + + ProcessId GetProcessId(); + + uint64 GetCurrentTimeInMs(); + + // Todo: Remove Sleep() entirely from our platform API. It cannot be used in the KMD and should not be used + // anywhere else either. + void Sleep(uint32 millisecTimeout); + + void GetProcessName(char* buffer, size_t bufferSize); + + void Strncpy(char* pDst, const char* pSrc, size_t dstSize); + + void Snprintf(char* pDst, size_t dstSize, const char* format, ...); + void Vsnprintf(char* pDst, size_t dstSize, const char* format, va_list args); + } + +#ifndef DD_PRINT_FUNC +#define DD_PRINT_FUNC Platform::DebugPrint +#else + void DD_PRINT_FUNC(LogLevel logLevel, const char* format, ...); +#endif + + template + inline void LogString(const char *format, Ts&&... args) + { + if (DD_WILL_PRINT(logLevel)) + { + DD_PRINT_FUNC(logLevel, format, Platform::Forward(args)...); + } + } + + //--------------------------------------------------------------------- + // CRC32 + // + // Calculate a 32bit crc using a the Sarwate look up table method. The original algorithm was created by + // Dilip V. Sarwate, and is based off of Stephan Brumme's implementation. See also: + // https://dl.acm.org/citation.cfm?doid=63030.63037 + // http://create.stephan-brumme.com/crc32/#sarwate + // + // Copyright (c) 2004-2006 Intel Corporation - All Rights Reserved + // + // + // + // This software program is licensed subject to the BSD License, + // available at http://www.opensource.org/licenses/bsd-license.html. + // + // Abstract: + // + // Tables for software CRC generation + // + static inline uint32 CRC32(const void *pData, size_t length, uint32 lastCRC = 0) + { + DD_STATIC_CONST uint32_t lookupTable[256] = + { + 0x00000000,0x77073096,0xEE0E612C,0x990951BA,0x076DC419,0x706AF48F,0xE963A535,0x9E6495A3, + 0x0EDB8832,0x79DCB8A4,0xE0D5E91E,0x97D2D988,0x09B64C2B,0x7EB17CBD,0xE7B82D07,0x90BF1D91, + 0x1DB71064,0x6AB020F2,0xF3B97148,0x84BE41DE,0x1ADAD47D,0x6DDDE4EB,0xF4D4B551,0x83D385C7, + 0x136C9856,0x646BA8C0,0xFD62F97A,0x8A65C9EC,0x14015C4F,0x63066CD9,0xFA0F3D63,0x8D080DF5, + 0x3B6E20C8,0x4C69105E,0xD56041E4,0xA2677172,0x3C03E4D1,0x4B04D447,0xD20D85FD,0xA50AB56B, + 0x35B5A8FA,0x42B2986C,0xDBBBC9D6,0xACBCF940,0x32D86CE3,0x45DF5C75,0xDCD60DCF,0xABD13D59, + 0x26D930AC,0x51DE003A,0xC8D75180,0xBFD06116,0x21B4F4B5,0x56B3C423,0xCFBA9599,0xB8BDA50F, + 0x2802B89E,0x5F058808,0xC60CD9B2,0xB10BE924,0x2F6F7C87,0x58684C11,0xC1611DAB,0xB6662D3D, + 0x76DC4190,0x01DB7106,0x98D220BC,0xEFD5102A,0x71B18589,0x06B6B51F,0x9FBFE4A5,0xE8B8D433, + 0x7807C9A2,0x0F00F934,0x9609A88E,0xE10E9818,0x7F6A0DBB,0x086D3D2D,0x91646C97,0xE6635C01, + 0x6B6B51F4,0x1C6C6162,0x856530D8,0xF262004E,0x6C0695ED,0x1B01A57B,0x8208F4C1,0xF50FC457, + 0x65B0D9C6,0x12B7E950,0x8BBEB8EA,0xFCB9887C,0x62DD1DDF,0x15DA2D49,0x8CD37CF3,0xFBD44C65, + 0x4DB26158,0x3AB551CE,0xA3BC0074,0xD4BB30E2,0x4ADFA541,0x3DD895D7,0xA4D1C46D,0xD3D6F4FB, + 0x4369E96A,0x346ED9FC,0xAD678846,0xDA60B8D0,0x44042D73,0x33031DE5,0xAA0A4C5F,0xDD0D7CC9, + 0x5005713C,0x270241AA,0xBE0B1010,0xC90C2086,0x5768B525,0x206F85B3,0xB966D409,0xCE61E49F, + 0x5EDEF90E,0x29D9C998,0xB0D09822,0xC7D7A8B4,0x59B33D17,0x2EB40D81,0xB7BD5C3B,0xC0BA6CAD, + 0xEDB88320,0x9ABFB3B6,0x03B6E20C,0x74B1D29A,0xEAD54739,0x9DD277AF,0x04DB2615,0x73DC1683, + 0xE3630B12,0x94643B84,0x0D6D6A3E,0x7A6A5AA8,0xE40ECF0B,0x9309FF9D,0x0A00AE27,0x7D079EB1, + 0xF00F9344,0x8708A3D2,0x1E01F268,0x6906C2FE,0xF762575D,0x806567CB,0x196C3671,0x6E6B06E7, + 0xFED41B76,0x89D32BE0,0x10DA7A5A,0x67DD4ACC,0xF9B9DF6F,0x8EBEEFF9,0x17B7BE43,0x60B08ED5, + 0xD6D6A3E8,0xA1D1937E,0x38D8C2C4,0x4FDFF252,0xD1BB67F1,0xA6BC5767,0x3FB506DD,0x48B2364B, + 0xD80D2BDA,0xAF0A1B4C,0x36034AF6,0x41047A60,0xDF60EFC3,0xA867DF55,0x316E8EEF,0x4669BE79, + 0xCB61B38C,0xBC66831A,0x256FD2A0,0x5268E236,0xCC0C7795,0xBB0B4703,0x220216B9,0x5505262F, + 0xC5BA3BBE,0xB2BD0B28,0x2BB45A92,0x5CB36A04,0xC2D7FFA7,0xB5D0CF31,0x2CD99E8B,0x5BDEAE1D, + 0x9B64C2B0,0xEC63F226,0x756AA39C,0x026D930A,0x9C0906A9,0xEB0E363F,0x72076785,0x05005713, + 0x95BF4A82,0xE2B87A14,0x7BB12BAE,0x0CB61B38,0x92D28E9B,0xE5D5BE0D,0x7CDCEFB7,0x0BDBDF21, + 0x86D3D2D4,0xF1D4E242,0x68DDB3F8,0x1FDA836E,0x81BE16CD,0xF6B9265B,0x6FB077E1,0x18B74777, + 0x88085AE6,0xFF0F6A70,0x66063BCA,0x11010B5C,0x8F659EFF,0xF862AE69,0x616BFFD3,0x166CCF45, + 0xA00AE278,0xD70DD2EE,0x4E048354,0x3903B3C2,0xA7672661,0xD06016F7,0x4969474D,0x3E6E77DB, + 0xAED16A4A,0xD9D65ADC,0x40DF0B66,0x37D83BF0,0xA9BCAE53,0xDEBB9EC5,0x47B2CF7F,0x30B5FFE9, + 0xBDBDF21C,0xCABAC28A,0x53B39330,0x24B4A3A6,0xBAD03605,0xCDD70693,0x54DE5729,0x23D967BF, + 0xB3667A2E,0xC4614AB8,0x5D681B02,0x2A6F2B94,0xB40BBE37,0xC30C8EA1,0x5A05DF1B,0x2D02EF8D, + }; + + uint32 crc = ~lastCRC; // same as lastCRC ^ 0xFFFFFFFF + const unsigned char* DD_RESTRICT pCurrent = (const unsigned char*)pData; + while (length--) + crc = (crc >> 8) ^ lookupTable[(crc & 0xFF) ^ *pCurrent++]; + return ~crc; + } +} diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/ddTransferManager.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/ddTransferManager.h new file mode 100644 index 000000000..1c39b96ca --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/ddTransferManager.h @@ -0,0 +1,247 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2017-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file ddTransferManager.h +* @brief Class declaration for TransferManager +*********************************************************************************************************************** +*/ + +#pragma once + +#include "gpuopen.h" +#include "util/sharedptr.h" +#include "util/vector.h" +#include "util/hashMap.h" +#include "protocols/systemProtocols.h" +#include "protocols/ddTransferClient.h" + +namespace DevDriver +{ + class IMsgChannel; + class SessionManager; + + namespace TransferProtocol + { + class TransferManager; + class TransferServer; + + // Size of an individual "chunk" within a transfer operation. + static const size_t kTransferChunkSizeInBytes = 4096; + + // A struct that represents a single transfer chunk + struct TransferChunk + { + uint8 Data[kTransferChunkSizeInBytes]; + }; + + // Base class for transfer blocks. + // A "block" is a binary blob of data associated with a unique id. Blocks can be created locally via the + // transfer manager's OpenServerBlock function. Once a server block is closed, it can be accessed remotely + // by other clients on the message bus. Remote clients can simply use their own transfer manager to open + // the desired block over the bus via OpenPullBlock. + class TransferBlock + { + public: + explicit TransferBlock(BlockId blockId) + : m_blockDataSize(0) + , m_blockId(blockId) {} + + // Returns the unique id associated with this block + BlockId GetBlockId() const { return m_blockId; } + + // Returns the size of the data contained within this block in bytes + size_t GetBlockDataSize() const { return m_blockDataSize; } + + protected: + size_t m_blockDataSize; // The size of the data held by the block + BlockId m_blockId; // The id associated with this block + }; + + // A server transfer block. + // Only supports writes and must be closed before the data can be accessed. + // Writes can only be performed on blocks that have not been closed. + class ServerBlock final : public TransferBlock + { + friend class TransferServer; + public: + explicit ServerBlock(const AllocCb& allocCb, BlockId blockId) + : TransferBlock(blockId) + , m_isClosed(false) + , m_chunks(allocCb) + , m_numPendingTransfers(0) + , m_transfersCompletedEvent(true) + , m_crc32(0) + {} + + // Writes numBytes bytes from pSrcBuffer into the block. + void Write(const uint8* pSrcBuffer, size_t numBytes); + + // Closes the block which exposes it to external clients and prevents further writes. + void Close(); + + // Resets the block to its initial state. Does not return allocated memory. + void Reset(); + + // Returns true if this block has been closed. + bool IsClosed() const { return m_isClosed; } + + // Returns a const pointer to the underlying data contained within the block, or null if it contains + // no data. + const uint8* GetBlockData() const { + return (m_blockDataSize > 0) ? reinterpret_cast(m_chunks.Data()) : nullptr; + } + + // Waits for all pending transfers to complete or for the timeout to expire. + Result WaitForPendingTransfers(uint32 timeoutInMs); + + // Returns a CRC32 for the current block + uint32 GetCrc32() const { return m_crc32; }; + + // Reserves at least the specified number of bytes in the internal storage. + void Reserve(size_t bytes); + + private: + // Notifies the block that a new transfer has begun. + void BeginTransfer(); + + // Notifies the block that an existing transfer has ended. + void EndTransfer(); + + bool m_isClosed; // A bool that indicates if the block is closed + Vector m_chunks; // A list of transfer chunks used to store data + Platform::Mutex m_pendingTransfersMutex; // A mutex used to control access to the pending transfers counter + uint32 m_numPendingTransfers; // A counter used to track the number of pending transfers + Platform::Event m_transfersCompletedEvent; // An event that is signaled when all pendings transfers are completed + uint32 m_crc32; // CRC covering all data stored in this block + }; + + // Backwards compatibility type alias. This will be removed with a future interface version change. + using LocalBlock = ServerBlock; + + // A transfer block for reading data from a remote client. + class PullBlock final : public TransferBlock + { + friend class TransferManager; + public: + // Reads up to bufferSize bytes into pDstBuffer from the block. + // Returns the number of bytes read in pBytesRead. + Result Read(uint8* pDstBuffer, size_t bufferSize, size_t* pBytesRead); + + private: + explicit PullBlock(IMsgChannel* pMsgChannel, BlockId blockId) + : TransferBlock(blockId) + , m_transferClient(pMsgChannel) + {} + + TransferClient m_transferClient; + }; + + // A transfer block for sending data to a remote server block + class PushBlock final : public TransferBlock + { + friend class TransferManager; + public: + // Reads up to bufferSize bytes from pDstBuffer and writes it into the remote block. + Result Write(const uint8* pDstBuffer, size_t bufferSize); + + // Closes the block, telling the server to save the data already transfered. + Result Finalize(); + + // Closes the block, telling the server to discard any data already transfered. + Result Discard(); + private: + explicit PushBlock(IMsgChannel* pMsgChannel, BlockId blockId) + : TransferBlock(blockId) + , m_transferClient(pMsgChannel) + {} + + TransferClient m_transferClient; + }; + + // Transfer manager class. + // Manages interactions with server/remote transfer blocks. + class TransferManager + { + public: + explicit TransferManager(const AllocCb& allocCb); + ~TransferManager(); + + Result Init(IMsgChannel* pMsgChannel, SessionManager* pSessionManager); + void Destroy(); + + // Returns a shared pointer to a server block or nullptr in the case of an error. + // Shared pointers are always used with server blocks to make sure they aren't destroyed + // while a remote download is in progress. + SharedPointer OpenServerBlock(); + + // Returns a shared pointer to a server block matching the requested block ID, or nullptr if it does + // not exist. + SharedPointer GetServerBlock(BlockId serverBlockId); + + // Releases a server block. This prevents new remote transfer requests from succeeding. + // This will clear the server block pointer inside the shared pointer object. + void CloseServerBlock(SharedPointer& pBlock); + + // Attempts to open a block exposed by a remote client over the message bus. + // Returns a valid PullBlock pointer on success and nullptr on failure. + PullBlock* OpenPullBlock(ClientId clientId, BlockId blockId); + + // Closes a pull block and deletes the underlying resources. + // This will null out the pull block pointer that is passed in as ppBlock. + void ClosePullBlock(PullBlock** ppBlock); + + // Attempts to open a block exposed by a remote client over the message bus. + // Returns a valid PushBlock pointer on success and nullptr on failure. + PushBlock* OpenPushBlock(ClientId clientId, BlockId blockId, size_t blockSize); + + // Closes a push block and deletes the underlying resources. + // This will null out the push block pointer that is passed in as ppBlock. + void ClosePushBlock(PushBlock** ppBlock); + + // Backwards compatibility - replaced by OpenServerBlock() + SharedPointer AcquireLocalBlock() + { + return OpenServerBlock(); + } + + // Backwards compatibility - replaced by CloseServerBlock() + void ReleaseLocalBlock(SharedPointer& pBlock) + { + CloseServerBlock(pBlock); + } + + private: + IMsgChannel* m_pMessageChannel; + SessionManager* m_pSessionManager; + TransferServer* m_pTransferServer; + AllocCb m_allocCb; + Platform::Random m_rng; + Platform::Mutex m_mutex; + + // A list of all the server blocks that are currently available to the TransferManager. + HashMap, 16> m_registeredServerBlocks; + }; + } // TransferProtocol +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/ddUriInterface.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/ddUriInterface.h new file mode 100644 index 000000000..0bede48ee --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/ddUriInterface.h @@ -0,0 +1,116 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file ddUriInterface.h +* @brief Declaration for public URI interfaces. +*********************************************************************************************************************** +*/ + +#pragma once + +#include "gpuopen.h" +#include "ddPlatform.h" +#include "util/sharedptr.h" + +namespace DevDriver +{ + namespace TransferProtocol + { + class ServerBlock; + } + + enum struct URIDataFormat : uint32 + { + Unknown = 0, + Text, + Binary, + Count + }; + + // A struct that represents a unique URI request + struct URIRequestContext + { + // Mutable arguments passed to the request + char* pRequestArguments; + + // A server block to write the response data into. + SharedPointer pResponseBlock; + + // The format of the data written into the response block. + URIDataFormat responseDataFormat; + }; + + struct URIResponseHeader + { + // The size of the response data in bytes + size_t responseDataSizeInBytes; + + // The format of the response data + URIDataFormat responseDataFormat; + }; + + // Base class for URI services + class IService + { + public: + virtual ~IService() {} + + // Returns the name of the service + virtual const char* GetName() const = 0; + +#if !DD_VERSION_SUPPORTS(GPUOPEN_URI_RESPONSE_FORMATS_VERSION) + // Attempts to handle a request from a client + // Deprecated + virtual Result HandleRequest(char* pArguments, + SharedPointer pBlock) + { + DD_UNUSED(pArguments); + DD_UNUSED(pBlock); + DD_NOT_IMPLEMENTED(); + return Result::Error; + } + + // Attempts to handle a request from a client + virtual Result HandleRequest(URIRequestContext* pContext) + { + DD_ASSERT(pContext != nullptr); + + const Result result = HandleRequest(pContext->pRequestArguments, + pContext->pResponseBlock); + if (result == Result::Success) + { + pContext->responseDataFormat = URIDataFormat::Text; + } + + return result; + } +#else + // Attempts to handle a request from a client + virtual Result HandleRequest(URIRequestContext* pContext) = 0; +#endif + protected: + IService() {}; + }; +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/devDriverClient.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/devDriverClient.h new file mode 100644 index 000000000..7b4290f34 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/devDriverClient.h @@ -0,0 +1,136 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file devDriverClient.h +* @brief Class declaration for DevDriverClient. +*********************************************************************************************************************** +*/ + +#pragma once + +#include "gpuopen.h" +#include "ddPlatform.h" +#include "msgChannel.h" +#include "msgTransport.h" +#include "protocols/systemProtocols.h" +#include "protocols/typemap.h" +#include "util/vector.h" +#include "protocolClient.h" + +namespace DevDriver +{ + class IMsgChannel; + class IProtocolClient; + + // Client Creation Info + // This struct extends the MessageChannelCreateInfo struct and adds information about the destination host + // the client will connect to. See msgChannel.h for a full list of members. + struct ClientCreateInfo : public MessageChannelCreateInfo + { + HostInfo connectionInfo; // Connection information describing how the Server should connect + // to the message bus. + }; + +#if !DD_VERSION_SUPPORTS(GPUOPEN_CREATE_INFO_CLEANUP_VERSION) + struct DevDriverClientCreateInfo + { + struct TransportCreateInfo : public MessageChannelCreateInfo + { + AllocCb allocCb; + HostInfo hostInfo; + TransportType type; + } transportCreateInfo; + }; +#endif + + class DevDriverClient + { + public: +#if !DD_VERSION_SUPPORTS(GPUOPEN_CREATE_INFO_CLEANUP_VERSION) + explicit DevDriverClient(const DevDriverClientCreateInfo& createInfo); +#endif + explicit DevDriverClient(const AllocCb& allocCb, + const ClientCreateInfo& createInfo); + ~DevDriverClient(); + + Result Initialize(); + void Destroy(); + + bool IsConnected() const; + IMsgChannel* GetMessageChannel() const; + + template + ProtocolClientType* AcquireProtocolClient() + { + using T = ProtocolClientType; + T* pProtocolClient = nullptr; + + Platform::LockGuard lock(m_clientLock); + + for (size_t index = 0; index < m_pUnusedClients.Size(); index++) + { + if (m_pUnusedClients[index]->GetProtocol() == protocol) + { + pProtocolClient = static_cast(m_pUnusedClients[index]); + DD_ASSERT(pProtocolClient->GetProtocol() == protocol); + m_pUnusedClients.Remove(index); + m_pClients.PushBack(pProtocolClient); + return pProtocolClient; + } + } + + pProtocolClient = DD_NEW(T, m_allocCb)(m_pMsgChannel); + if (pProtocolClient != nullptr) + { + m_pClients.PushBack(pProtocolClient); + } + + return pProtocolClient; + } + + void ReleaseProtocolClient(IProtocolClient* pProtocolClient) + { + Platform::LockGuard lock(m_clientLock); + if (pProtocolClient != nullptr && (m_pClients.Remove(pProtocolClient) > 0)) + { + pProtocolClient->Disconnect(); + m_pUnusedClients.PushBack(pProtocolClient); + } + } + + private: + DD_STATIC_CONST uint32 kRegistrationTimeoutInMs = 1000; + IMsgChannel* m_pMsgChannel; + + Platform::AtomicLock m_clientLock; + Vector m_pClients; + Vector m_pUnusedClients; + + // Allocator and create info are stored at the end of the struct since they will be used infrequently + AllocCb m_allocCb; + ClientCreateInfo m_createInfo; + }; + +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/devDriverServer.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/devDriverServer.h new file mode 100644 index 000000000..599138f2e --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/devDriverServer.h @@ -0,0 +1,117 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file devDriverServer.h +* @brief Class declaration for DevDriverServer. +*********************************************************************************************************************** +*/ + +#pragma once + +#include "gpuopen.h" +#include "msgChannel.h" +#include "msgTransport.h" +#include "protocols/systemProtocols.h" +#include "protocols/typemap.h" + +namespace DevDriver +{ + class IProtocolServer; + + // Server Creation Info + // This struct extends the MessageChannelCreateInfo struct and adds information about the destination host + // the client will connect to. It additionally allows specifying protocol servers to enable during initialization. + // See msgChannel.h for a full list of members. + struct ServerCreateInfo : public MessageChannelCreateInfo + { + HostInfo connectionInfo; // Connection information describing how the Server should connect + // to the message bus. + ProtocolFlags servers; // Set of boolean values indicating which servers should be created + // during initialization. + }; + +#if !DD_VERSION_SUPPORTS(GPUOPEN_CREATE_INFO_CLEANUP_VERSION) + struct DevDriverServerCreateInfo + { + struct TransportCreateInfo : public MessageChannelCreateInfo + { + AllocCb allocCb; + HostInfo hostInfo; + TransportType type; + } transportCreateInfo; + ProtocolFlags enabledProtocols; + }; +#endif + +#if !DD_VERSION_SUPPORTS(GPUOPEN_DISTRIBUTED_STATUS_FLAGS_VERSION) + Result QueryDevDriverStatus(const TransportType type, StatusFlags* pFlags, HostInfo *pHostInfo = nullptr); +#endif + + DD_STATIC_CONST uint32 kQueryStatusTimeoutInMs = 50; + + class DevDriverServer + { + public: + static bool IsConnectionAvailable(const HostInfo& hostInfo, uint32 timeout = kQueryStatusTimeoutInMs); + + explicit DevDriverServer(const AllocCb& allocCb, const ServerCreateInfo& createInfo); + ~DevDriverServer(); + + Result Initialize(); + void Finalize(); + void Destroy(); + + bool IsConnected() const; + IMsgChannel* GetMessageChannel() const; + + LoggingProtocol::LoggingServer* GetLoggingServer(); + SettingsProtocol::SettingsServer* GetSettingsServer(); + DriverControlProtocol::DriverControlServer* GetDriverControlServer(); + RGPProtocol::RGPServer* GetRGPServer(); + +#if !DD_VERSION_SUPPORTS(GPUOPEN_CREATE_INFO_CLEANUP_VERSION) + static bool IsConnectionAvailable(const TransportType type, uint32 timeout = kQueryStatusTimeoutInMs); + explicit DevDriverServer(const DevDriverServerCreateInfo& createInfo); +#endif + private: + Result InitializeProtocols(); + void DestroyProtocols(); + + Result RegisterProtocol(Protocol protocol); + void UnregisterProtocol(Protocol protocol); + void FinalizeProtocol(Protocol protocol); + + IMsgChannel* m_pMsgChannel; + AllocCb m_allocCb; + ServerCreateInfo m_createInfo; + + template + inline Result RegisterProtocol(Args... args); + + template + inline ProtocolServerType* GetServer(); + }; + +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/gpuopen.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/gpuopen.h new file mode 100644 index 000000000..4929edf65 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/gpuopen.h @@ -0,0 +1,531 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#pragma once + +#define GPUOPEN_INTERFACE_MAJOR_VERSION 31 +#define GPUOPEN_INTERFACE_MINOR_VERSION 0 + +#define GPUOPEN_INTERFACE_VERSION ((GPUOPEN_INTERFACE_MAJOR_VERSION << 16) | GPUOPEN_INTERFACE_MINOR_VERSION) + +#define GPUOPEN_MINIMUM_INTERFACE_MAJOR_VERSION 26 + +#ifndef GPUOPEN_CLIENT_INTERFACE_MAJOR_VERSION +static_assert(false, "Client must define GPUOPEN_CLIENT_INTERFACE_MAJOR_VERSION."); +#else +static_assert((GPUOPEN_CLIENT_INTERFACE_MAJOR_VERSION >= GPUOPEN_MINIMUM_INTERFACE_MAJOR_VERSION) && + (GPUOPEN_CLIENT_INTERFACE_MAJOR_VERSION <= GPUOPEN_INTERFACE_MAJOR_VERSION), + "The specified GPUOPEN_CLIENT_INTERFACE_MAJOR_VERSION is not supported."); +#endif + +/* +*********************************************************************************************************************** +*| Version | Change Description | +*| ------- | ---------------------------------------------------------------------------------------------------------| +*| 31.0 | Clean up DevDriverClient and DevDriverServer create info structs. Replace TransportCreateInfo | +*| | struct with MessageChannelCreateInfo and HostInfo structs. | +*| 30.2 | Added support for RGP v6 protocol which supports trace trigger markers. | +*| 30.1 | Add Push transfer support to the transfer protocol. Added PushBlock class, added v2 of the | +*| | TransferProtocol, and did a lot of internal cleanup. Legacy interfaces will be deprecated in a future | +*| | interface version change alongside URI changes. | +*| 30.0 | Remove CloseSession and OrphanSession from the public ISession object interface, and move the | +*| | functionality into the Session class. | +*| 29.0 | Added a ResponseDataFormat enum to the URI protocol to distinguish between binary and text responses. | +*| 28.0 | Formally deprecate legacy KMD client manager support in the Listener. | +*| 27.2 | Updated FindFirstClient to support returning the matching ClientMetadata struct. | +*| 27.1 | Added PipelineDumpsEnabled status flag. | +*| 27.0 | Deprecate global client status flags + replace it with client metadata. | +*| 26.0 | Add new trace parameters in the RGP protocol. | +*| 25.0 | Initial refactor of LoggingProtocol. Removes Subcategories, being able to set/clear filter outside of a | +*| | trace, and significantly reduces the complexity that is involved in using it. | +*| 24.0 | Expanded driver initialization concept in driver control protocol. | +*| 23.0 | Modified RGP client API usage pattern to be uniform across protocol versions. | +*| 22.0 | Refactor RGP client interface to support calculating transfer progress. | +*| 21.1 | Added backwards compatible workaround for the session termination bug until we get the fix in mainline. | +*| 21.0 | Enable link disconnection detection for socket based transports. | +*| 20.0 | Added support for specifying the clock mode used during RGP profiling. | +*| 19.0 | Refactor platform thread functions so that they are contained in a class. This is the last part of the | +*| | platform library that needed to be refactored, so future work will be focused on migrating the message | +*| | bus components to use the main platform library again. | +*| 18.0 | Consolidate DevDriver::DebugLevel and DevDriver::Message::DebugLevel into DevDriver::LogLevel. | +*| 17.0 | Rename DD_VERSION_IS_SUPPORTED macro to DD_VERSION_SUPPORTS for conciseness. | +*| 16.1 | Rework session version negotiation to allow clients to support multiple server versions. | +*| 16.0 | Change semantics of CreateProtocolClient to AcquireProtocolClient. This aligns better with | +*| | ReleaseProtoclClient in terms of semantics. | +*| 15.0 | Added support for memory allocator callbacks via AllocCb. | +*| 14.1 | Added DisableTrace call in RGP server to allow drivers to disable future traces if necessary. | +*| 14.0 | Add TraceParameters to the RGP protocol to allow for configuration of trace behavior. | +*| 13.0 | Deprecate DevDriverClient::CreateProtocolClient() in favor of typesafe templated version. | +*| 12.0 | Deprecate API features tied to legacy network protocol versions: | +*| | * Replace ConnectToRemoteClient with Connect, which now returns more detailed errors on failure | +*| | * Eliminate Send and ReceiveSessionMessage functions in IMsgChannel and SessionManager | +*| | * Rename AuthenticationFailed to VersionMismatch since it is more semantically accurate | +*| | * Update IMsgChannel::Update so that it takes a default timeout value, get rid of m_receiveTimeoutInMs | +*| 11.5 | Updated server to remove GetVersion() call and pass version into AcceptSession() instead. This allows | +*| | servers to potentially implement backwards compatibility for older client versions. Additionally, | +*| | completely eliminate SessionTermination type in favor of expanding Result type. This allows propagating | +*| | more information on connection failures back to clients, as well as streamlines some code. | +*| 11.4 | Implement per-protocol versioning. Client protocol is sent as part of session request, server decides | +*| | whether or not to accept session both from client and from version. Also rearrange how certain network | +*| | operations work: Syn now stores the initial session ID in the sessionId field of the message, Rst now | +*| | includes a result code, and closing a session now implicitly flushes both the client/server. Rst | +*| | Is also sent on just about every unknown session packet received, allowing faster error detection and | +*| | recovery. Bump network version number | +*| 11.3 | Change ProcessId type from 64bit to 32bit integer and bump network protocol version. | +*| 11.2 | Update the network protocol to give external protocols values from 0-223 and system protocols 224-255. | +*| | Also clean up + deprecate some of the constants associated with protocols. | +*| 11.1 | Force alignment of all network transmitted structs, as well as pad. This is a breaking change for the | +*| | network protocol, but is otherwise API compatible. | +*| 11.0 | Deprecate the Protocol::ClientManangement enum, as well as ReadMessageBuffer and SendMessageBuffer in | +*| | message.lib. | +*| 10.0 | Remove callback from MessageChannel to prevent usage that can cause deadlocking. | +*| 9.0 | Formalized support for selective discard of non-session messages based on right in the message. | +*| | Implementation is that the sequence field of a message can be populated with the contents of a | +*| | ClientMetadata struct, which is then used by the receiving message channel to determine if it should | +*| | respond. Decision is based on whether or not the metadata matches the metadata of the receiving client. | +*| 8.0 | Added support for default settings values in the settings protocol. Removed support for min and max | +*| | settings values since the scripts don't actually support those anyways. | +*| 7.0 | Added a Finalize function to DevDriverServer and all protocol server objects. This function now handles | +*| | the wait on start functionality for drivers internally. Finalize should now be called instead of the old | +*| | wait on start logic in client drivers. | +*| 6.0 | Update client protocol management so that DevDriverClient no longer caches a single instance of each | +*| | client protocol, and add ability for clients to directly create more than one client protocol instance. | +*| | Additionally, make changes to underlying message channel/transport API that is not backwards compatible, | +*| | as well as rename QueryClientInfoResponse to ClientInfoResponse and QueryClientInfoResponsePayload to | +*| | ClientInfoStruct. | +*| 5.0 | Update network protocol to allow specifying status flags at registration time, and add system message. | +*| | to indicate when a driver has been halted. Additionally, this changes the format of the client | +*| | registration packets so as to better detect version mismatch. It also fixes the ClientManangement typo. | +*| 4.0 | Refactor interface so as to better delineate between system protcols/client protocols, as well as add | +*| | ability to query protocol availability. Requires version bump, so also formally deprecated | +*| | Result::Timeout and ClientStatusFlags::ProfilingEnabled, as well as moved entire SessionProtocol | +*| | namespace out of the public headers. | +*| 3.1 | Introduce kNumberClientProtocols to replace usage of Protocol::Count | +*| 3.0 | Rename SettingsProtocol::SettingType::Bool to Boolean to avoid conflict with Xlib macro. Additionally | +*| | formally deprecate Result::Timeout. | +*| 2.2 | Added None (0) to ClientStatusFlags enum. | +*| 2.1 | Added kNamedPipeName to global namespace. | +*| 2.0 | Added functionality for enabling and disabling traces in RGPServer. Traces must now be explicitly | +*| | enabled before remote trace requests will succeed. | +*| 1.2 | Added AbortTrace() function to RGPServer. | +*| 1.1 | Added support for RGP protocol. | +*| 1.0 | Initial versioned release. | +*********************************************************************************************************************** +*/ + +#define GPUOPEN_CREATE_INFO_CLEANUP_VERSION 31 +#define GPUOPEN_SESSION_INTERFACE_CLEANUP_VERSION 30 +#define GPUOPEN_URI_RESPONSE_FORMATS_VERSION 29 +#define GPUOPEN_DEPRECATE_LEGACY_KMD_VERSION 28 +#define GPUOPEN_DISTRIBUTED_STATUS_FLAGS_VERSION 27 +#define GPUOPEN_RGP_TRACE_PARAMETERS_V3_VERSION 26 +#define GPUOPEN_LOGGING_SIMPLIFICATION_VERSION 25 +#define GPUOPEN_DRIVERCONTROL_INITIALIZATION_VERSION 24 +#define GPUOPEN_RGP_UNIFORM_API_VERSION 23 +#define GPUOPEN_RGP_PROGRESS_VERSION 22 +#define GPUOPEN_KEEPALIVE_VERSION 21 +#define GPUOPEN_PROFILING_CLOCK_MODES_VERSION 20 +#define GPUOPEN_THREAD_REFACTOR_VERSION 19 +#define GPUOPEN_LOGLEVEL_CLEANUP_VERSION 18 +#define GPUOPEN_RENAME_MACRO_VERSION 17 +#define GPUOPEN_PROTOCOL_CLIENT_REUSE_VERSION 16 +#define GPUOPEN_MEMORY_ALLOCATORS_VERSION 15 +#define GPUOPEN_RGP_TRACE_PARAMETERS_VERSION 14 +#define GPUOPEN_DEPRECATE_CREATEPROTOCOLCLIENT_VERSION 13 +#define GPUOPEN_DEPRECATE_LEGACY_NETAPI_VERSION 12 +#define GPUOPEN_POST_GDC_CLEANUP_VERSION 11 +#define GPUOPEN_DEPRECATE_EXTERNAL_CALLBACK_VERSION 10 +#define GPUOPEN_SELECTIVE_RESPOND_VERSION 9 +#define GPUOPEN_DEFAULT_SETTINGS_VERSION 8 +#define GPUOPEN_SERVER_FINALIZE_VERSION 7 +#define GPUOPEN_DEPRECATE_LEGACY_VERSION 6 +#define GPUOPEN_CLIENT_REGISTRATION_VERSION 5 +#define GPUOPEN_PROTOCOL_CLEANUP_VERSION 4 +#define GPUOPEN_LINUX_BUILD_VERSION 3 +#define GPUOPEN_EXPLICIT_ENABLE_RGP_VERSION 2 +#define GPUOPEN_INITIAL_VERSION 1 + +#include +#include + +#if defined(_MSC_VER) +#define DD_ALIGNAS(x)__declspec(align(x)) +#if _MSC_VER < 1900 +#define DD_STATIC_CONST static const +#else +#define DD_STATIC_CONST static constexpr +#endif +#endif + +#if !defined(DD_STATIC_CONST) +#if defined(__cplusplus) && __cplusplus >= 201103L +#define DD_STATIC_CONST static constexpr +#else +#define DD_STATIC_CONST static const +#endif +#endif + +#if !defined(DD_ALIGNAS) +#if defined(__cplusplus) && __cplusplus >= 201103L +#define DD_ALIGNAS(x) alignas(x) +#else +static_assert(false, "Error: unsupported compiler detected. Support is required to build."); +#endif +#endif + +// Creates a structure with the specified name and alignment. +#define DD_ALIGNED_STRUCT(name, alignment) struct DD_ALIGNAS(alignment) name + +// Creates a structure with the specified alignment, and mark it as final to ensure it cannot be used as a parent class +#define DD_NETWORK_STRUCT(name, alignment) struct DD_ALIGNAS(alignment) name final + +#define DD_CHECK_SIZE(x, size) static_assert(sizeof(x) == size_t(size), #x " size has changed unexpectedly") + +#define DD_VERSION_SUPPORTS(x) (GPUOPEN_CLIENT_INTERFACE_MAJOR_VERSION >= x) + +#define DD_PTR_TO_HANDLE(x) ((DevDriver::Handle)(uintptr_t)(x)) + +#define DD_UNUSED(x) (static_cast(x)) + +#define DD_SANITIZE_RESULT(x) ((x != Result::Success) ? Result::Error : x) + +namespace DevDriver +{ + typedef int8_t int8; ///< 8-bit integer. + typedef int16_t int16; ///< 16-bit integer. + typedef int32_t int32; ///< 32-bit integer. + typedef int64_t int64; ///< 64-bit integer. + typedef uint8_t uint8; ///< Unsigned 8-bit integer. + typedef uint16_t uint16; ///< Unsigned 16-bit integer. + typedef uint32_t uint32; ///< Unsigned 32-bit integer. + typedef uint64_t uint64; ///< Unsigned 64-bit integer. + + typedef uint64_t Handle; + + typedef uint16_t ClientId; + typedef uint32_t SessionId; + typedef uint32_t ProcessId; + typedef uint8_t MessageCode; + typedef uint16_t WindowSize; + typedef uint32_t Size; + typedef uint64_t Sequence; + typedef uint16_t Version; + typedef uint16_t StatusFlags; + +#if !DD_VERSION_SUPPORTS(GPUOPEN_DISTRIBUTED_STATUS_FLAGS_VERSION) + typedef StatusFlags ClientFlags; +#endif + + DD_STATIC_CONST Handle kNullPtr = DD_PTR_TO_HANDLE(NULL); + DD_STATIC_CONST uint32 kInfiniteTimeout = ~(0u); + DD_STATIC_CONST uint32 kNoWait = (0u); + + //////////////////////////// + // Common result codes + enum struct Result : uint32 + { + Success = 0, + Error = 1, + NotReady = 2, + VersionMismatch = 3, + Unavailable = 4, + Rejected = 5, + EndOfStream = 6, + Aborted = 7, + InsufficientMemory = 8 + }; + + //////////////////////////// + // Common logging levels + enum struct LogLevel : uint8 + { + Debug = 0, + Verbose, + Info, + Alert, + Error, + Always, + Count, + Never = 0xFF + }; + + //////////////////////////// + // Client status codes + enum struct ClientStatusFlags : StatusFlags + { + None = 0, + DeveloperModeEnabled = (1 << 0), + HaltOnConnect = (1 << 1), + GpuCrashDumpsEnabled = (1 << 2), + PipelineDumpsEnabled = (1 << 3) + }; + + DD_CHECK_SIZE(ClientId, 2); + DD_STATIC_CONST int16 kRouterPrefixWidth = 3; + DD_STATIC_CONST int16 kRouterPrefixShift = (int16)(16 - kRouterPrefixWidth); + DD_STATIC_CONST ClientId kClientIdMask = (1 << kRouterPrefixShift) - 1; + DD_STATIC_CONST ClientId kRouterPrefixMask = static_cast(~(kClientIdMask)); + + union ProtocolFlags + { + struct DD_ALIGNAS(4) + { + uint32 logging : 1; + uint32 settings : 1; + uint32 driverControl : 1; + uint32 rgp : 1; + uint32 etw : 1; + uint32 gpuCrashDump : 1; + uint32 reserved : 26; + }; + uint32 value; + }; + + DD_CHECK_SIZE(ProtocolFlags, 4); + + //////////////////////////// + // Component definitions + enum struct Component : uint8 + { + Unknown = 0, + Server, + Tool, + Driver, + Count + }; + + union ClientMetadata + { + struct DD_ALIGNAS(8) + { + ProtocolFlags protocols; + Component clientType; + uint8 reserved; + StatusFlags status; + }; + uint64 value; + + // Test if all non-zero fields in the ClientMetadata value are contained in the function parameter + bool Matches(const ClientMetadata &right) const + { + bool result = true; + if (value != 0) + { + // Component is an enum, so the comparison needs to be equality + const bool clientTypeMatches = + (clientType != Component::Unknown) + ? (clientType == right.clientType) + : true; + + // ProtocolFlags is a bit field, so we can do a bitwise comparison + const bool protocolMatches = + (protocols.value != 0) + ? (protocols.value & right.protocols.value) == protocols.value + : true; + // StatusFlags is a bit field, so we can do a bitwise comparison + const bool statusMatches = + (status != 0) + ? (status & right.status) == status + : true; + result = clientTypeMatches & protocolMatches & statusMatches; + } + return result; + } + + // Test if any non-zero fields in the ClientMetadata value are contained in the function parameter + bool MatchesAny(const ClientMetadata &right) const + { + bool result = true; + if (value != 0) + { + // Component is an enum, so the comparison needs to be equality + const bool clientTypeMatches = (clientType == right.clientType); + // ProtocolFlags is a bit field, so we can do a bitwise comparison + const bool protocolMatches = (protocols.value & right.protocols.value) != 0; + // StatusFlags is a bit field, so we can do a bitwise comparison + const bool statusMatches = (status & right.status) != 0; + result = clientTypeMatches | protocolMatches | statusMatches; + } + return result; + } + }; + + DD_CHECK_SIZE(ClientMetadata, 8); + + //////////////////////////// + // Protocol definitions + enum struct Protocol : uint8 + { + DriverControl = 0, + Logging, + Settings, + RGP, + ETW, + GpuCrashDump, + DefinedProtocolCount, + + // System enumerations + MaxUserProtocol = 223, + /* RESERVED FOR SYSTEM USE */ + Transfer = 251, + URI = 252, + Session = 253, + ClientManagement = 254, + System = 255, + }; + + // this gives you the number of pre-defined user protocols that exist + DD_STATIC_CONST uint32 kNumberClientProtocols = static_cast(Protocol::DefinedProtocolCount); + + // this gives you the maximum number of client protocols you can reserve. + DD_STATIC_CONST uint32 kMaxClientProtocolId = static_cast(Protocol::MaxUserProtocol); + + static_assert(kNumberClientProtocols <= (kMaxClientProtocolId + 1), "Invalid protocol definitions specified"); + + /////////////////////// + // General definitions + DD_STATIC_CONST uint32 kMessageVersion = 1011; + + // Max string size for names and messages + DD_STATIC_CONST Size kMaxStringLength = 128; + + // Broadcast client ID + DD_STATIC_CONST ClientId kBroadcastClientId = 0; + + // Invalid Session ID + DD_STATIC_CONST SessionId kInvalidSessionId = 0; + +#if !DD_VERSION_SUPPORTS(GPUOPEN_CREATE_INFO_CLEANUP_VERSION) + // Default named pipe name + DD_STATIC_CONST char kNamedPipeName[] = "\\\\.\\pipe\\AMD-Developer-Service"; + +#endif + // Default network port number + DD_STATIC_CONST uint32 kDefaultNetworkPort = 27300; + + // Transport type enumeration + enum class TransportType : uint32 + { + Local = 0, + Remote, + }; + + // Struct used to designate a transport type, port number, and hostname + struct HostInfo + { + TransportType type; // Transport type, as defined above + uint32 port; // Port number if applicable + char hostname[kMaxStringLength]; // Host address, address, or path + }; + + // Default local host information + DD_STATIC_CONST HostInfo kDefaultLocalHost = + { + TransportType::Remote, + kDefaultNetworkPort, + "127.0.0.1" + }; + + // Default named pipe information + DD_STATIC_CONST HostInfo kDefaultNamedPipe = + { + TransportType::Local, + 0, +#if defined(__APPLE__) + "/tmp/com.amd.AMD-Developer-Service" +#else + "\\\\.\\pipe\\AMD-Developer-Service" +#endif + + }; + + //////////////////////////// + // Common definition of a message header + // + // todo: better packing of these values + // - payloadSize needs to be moved to where windowSize is currently + // - windowSize, sessionId, and sequence need to be moved into protocol specific payloads + // - minimum alignment could then be reduced to 2 bytes, and min packet size would be 8 bytes + // - downside is that pretty much every protocol would need to define some extra data + + DD_NETWORK_STRUCT(MessageHeader, 8) + { + // source and destination client ids + ClientId srcClientId; // 0 - 15 + ClientId dstClientId; // 16 - 31 + + // protocol and command + Protocol protocolId; // 31 - 38 + MessageCode messageId; // 39 - 47 + WindowSize windowSize; // 48 - 63 + + // payload size + current session ID + Size payloadSize; // 64 - 91 + SessionId sessionId; // 92 - 127 + + // sequence number when using a session + Sequence sequence; // 128 - 191 + }; + + DD_CHECK_SIZE(MessageHeader, 24); + + DD_STATIC_CONST Size kMaxMessageSizeInBytes = 1408; + DD_STATIC_CONST Size kMaxPayloadSizeInBytes = (kMaxMessageSizeInBytes - sizeof(MessageHeader)); + + DD_NETWORK_STRUCT(MessageBuffer, 8) + { + MessageHeader header; + char payload[kMaxPayloadSizeInBytes]; + }; + + DD_CHECK_SIZE(MessageBuffer, sizeof(MessageHeader) + kMaxPayloadSizeInBytes); + + // tripwire - this intentionally will break if the message version changes. Since these are breaking changes already, we need to address + // this problem when it happens. + static_assert(kMessageVersion == 1011, "ClientInfoStruct needs to be updated so that clientName is long enough to support a full path"); + // todo: shorten clientDescription to 64bytes and make clientName 320bytes to support full path + DD_NETWORK_STRUCT(ClientInfoStruct, 8) + { + char clientName[kMaxStringLength]; + char clientDescription[kMaxStringLength]; + // reserve 128bytes in case we need another string in the future + char reserved[kMaxStringLength]; + ClientMetadata metadata; + ProcessId processId; + // pad this out to 512 bytes for future expansion + char padding[116]; + }; + + DD_CHECK_SIZE(ClientInfoStruct, 512); + + typedef void*(*AllocFunc)(void* pUserdata, size_t size, size_t alignment, bool zero); + typedef void(*FreeFunc)(void* pUserdata, void* pMemory); + + struct AllocCb + { + void* pUserdata; + AllocFunc pfnAlloc; + FreeFunc pfnFree; + }; +} diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/msgChannel.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/msgChannel.h new file mode 100644 index 000000000..a337f5086 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/msgChannel.h @@ -0,0 +1,164 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file msgChannel.h +* @brief Interface declaration for IMsgChannel +*********************************************************************************************************************** +*/ + +#pragma once + +#include "gpuopen.h" +#include "protocolClient.h" +#include "protocolServer.h" +#include "msgTransport.h" + +namespace DevDriver +{ + class IService; + + namespace TransferProtocol + { + class TransferManager; + } + + DD_STATIC_CONST uint32 kDefaultUpdateTimeoutInMs = 10; + DD_STATIC_CONST uint32 kFindClientTimeout = 500; + + // Struct of information required to initialize an IMsgChannel instance + struct MessageChannelCreateInfo + { + StatusFlags initialFlags; // Initial client status flags. + Component componentType; // Type of component the message channel represents. + bool createUpdateThread; // Create a background processing thread for the message + // channel. This should only be set to false if the + // owning object is able to call IMsgChannel::Update() + // at least once per frame. + char clientDescription[kMaxStringLength]; // Description of the client provided to other clients on + // the message bus. + }; + + class IMsgChannel + { + public: + virtual ~IMsgChannel() {} + + // Register, unregister, or check connected status. + virtual Result Register(uint32 timeoutInMs = ~(0u)) = 0; + virtual Result Unregister() = 0; + virtual bool IsConnected() = 0; + + // Send, receive, and forward messages + virtual Result Send(ClientId dstClientId, + Protocol protocol, + MessageCode message, + const ClientMetadata& metadata, + uint32 payloadSizeInBytes, + const void* pPayload) = 0; + virtual Result Receive(MessageBuffer& message, uint32 timeoutInMs) = 0; + virtual Result Forward(const MessageBuffer& messageBuffer) = 0; + + // Register, unregister, and retrieve IProtocolServer objects + virtual Result RegisterProtocolServer(IProtocolServer* pServer) = 0; + virtual Result UnregisterProtocolServer(IProtocolServer* pServer) = 0; + virtual IProtocolServer* GetProtocolServer(Protocol protocol) = 0; + + // Initiates a connection using the provided protocol client to the specified destionation client id + virtual Result ConnectProtocolClient(IProtocolClient* pProtocolClient, ClientId dstClientId) = 0; + + // Register or Unregister an IService object + virtual Result RegisterService(IService* pService) = 0; + virtual Result UnregisterService(IService* pService) = 0; + + // Get the allocator used to create this message channel + virtual const AllocCb& GetAllocCb() const = 0; + + // Returns client information for the first client to respond that matches the specified filter + virtual Result FindFirstClient(const ClientMetadata& filter, + ClientId* pClientId, + uint32 timeoutInMs = kFindClientTimeout, + ClientMetadata* pClientMetadata = nullptr) = 0; + + // Get the client ID, or returns kBroadcastClientId if disconnected. + virtual ClientId GetClientId() const = 0; + + // Get the client information struct for the message channel. + virtual const ClientInfoStruct& GetClientInfo() const = 0; + + // Get a human-readable string describing the connection type. + virtual const char* GetTransportName() const = 0; + + // Set and get all client status flags. + virtual Result SetStatusFlags(StatusFlags flags) = 0; + virtual StatusFlags GetStatusFlags() const = 0; + + // Set the specified client status flag. + template + Result SetStatusFlag(bool enable) + { + Result toggleResult = Result::Success; + StatusFlags oldFlags = GetStatusFlags(); + StatusFlags newFlags; + + if (enable) + { + // Toggle developer mode + newFlags = oldFlags | static_cast(flag); + } + else + { + // Toggle developer mode + newFlags = oldFlags & ~static_cast(flag); + } + + if (newFlags != oldFlags) + { + toggleResult = SetStatusFlags(newFlags); + } + return toggleResult; + } + + // Get the specified client status flag. + template + bool GetStatusFlag() const + { + return ((GetStatusFlags() & static_cast(flag)) != 0); + } + + // Utility functions that should probably not be publicly exposed. + // TODO: Refactor surrounding code to eliminate these. + virtual TransferProtocol::TransferManager& GetTransferManager() = 0; + virtual void Update(uint32 timeoutInMs = kDefaultUpdateTimeoutInMs) = 0; + + // Backwards compatibility + Result EstablishSession(ClientId dstClientId, IProtocolClient* pProtocolClient) + { + return ConnectProtocolClient(pProtocolClient, dstClientId); + } + protected: + IMsgChannel() {}; + }; + +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/msgTransport.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/msgTransport.h new file mode 100644 index 000000000..4a154c200 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/msgTransport.h @@ -0,0 +1,79 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file msgChannel.h +* @brief Interface declaration for IMsgChannel +*********************************************************************************************************************** +*/ + +#pragma once + +#include "gpuopen.h" + +namespace DevDriver +{ + class IMsgTransport + { + public: + virtual ~IMsgTransport() {} + + // Connect and disconnect from the transport. + virtual Result Connect(ClientId* pClientId, uint32 timeoutInMs) = 0; + virtual Result Disconnect() = 0; + + // Read and Write messages from a connected transport + virtual Result WriteMessage(const MessageBuffer &messageBuffer) = 0; + virtual Result ReadMessage(MessageBuffer &messageBuffer, uint32 timeoutInMs) = 0; + + // Get a human-readable string describing the connection type. + virtual const char* GetTransportName() const = 0; + +#if !DD_VERSION_SUPPORTS(GPUOPEN_DISTRIBUTED_STATUS_FLAGS_VERSION) + virtual Result UpdateClientStatus(ClientId clientId, StatusFlags flags) = 0; +#endif + + // Static method to be implemented by individual transports + // true indicates that the transport is incapable of detecting + // dropped connections and some form of keep-alive is required + // false indicates that the transport can properly detect dropped + // connections + DD_STATIC_CONST bool RequiresKeepAlive() + { + return false; + } + + // Static method to be implemented by individual transports + // true indicates that Connect is expected to also negotiate a client ID + // false indicates that the MessageChannel needs to do it's own client ID + // negotiation, e.g. in the case of network connections + DD_STATIC_CONST bool RequiresClientRegistration() + { + return false; + } + protected: + IMsgTransport() {} + }; + +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/posix/ddPosixPlatform.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/posix/ddPosixPlatform.h new file mode 100644 index 000000000..9385dbb51 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/posix/ddPosixPlatform.h @@ -0,0 +1,126 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file ddPosixPlatform.h +* @brief POSIX Platform layer definition +*********************************************************************************************************************** +*/ + +#pragma once + +#include +#include +#include +#include +#include + +#if defined(__APPLE__) +#include +#define DD_DARWIN +#elif defined(__linux__) +#include +#define DD_LINUX +#else +static_assert(false, "Unknown platform detected") +#endif + +#define DD_RESTRICT __restrict__ + +namespace DevDriver +{ + namespace Platform + { + template + int RetryTemporaryFailure(T& func, Args&&... args) + { + int retval; + do + { + retval = func(args...); + } while (retval == -1 && errno == EINTR); + return retval; + } + + typedef volatile int32 Atomic; + + struct EmptyStruct + { + }; + + struct EventStorage + { + pthread_mutex_t mutex; + pthread_cond_t condition; + volatile bool isSet; + }; + + typedef pthread_mutex_t MutexStorage; + +#if defined(DD_LINUX) + typedef sem_t SemaphoreStorage; + typedef drand48_data RandomStorage; +#endif + + struct ThreadStorage + { + void(*callback)(void *); + void *parameter; + pthread_t handle; + }; + + inline static void DebugBreak( + const char* pFile, + unsigned int line, + const char* pFunction, + const char* pAssertion) __attribute__((noreturn)); + + static void DebugBreak( + const char* pFile, + unsigned int line, + const char* pFunction, + const char* pAssertion) + { + DD_UNUSED(pFile); + DD_UNUSED(line); + DD_UNUSED(pFunction); + DD_UNUSED(pAssertion); + +#if defined(DEVDRIVER_HARD_ASSERT) +#if !defined(NDEBUG) +#if defined(DD_LINUX) + __assert_fail(pAssertion, pFile, line, pFunction); +#endif +#else +#if defined(SIGTRAP) + raise(SIGTRAP); +#else + raise(SIGINT); +#endif +#endif +#endif + __builtin_unreachable(); + } + } +} diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocolClient.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocolClient.h new file mode 100644 index 000000000..446cb8ef2 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocolClient.h @@ -0,0 +1,59 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file gpuopenProtocolClient.h +* @brief Interface declaration for IProtocolClient. +*********************************************************************************************************************** +*/ + +#pragma once + +#include "gpuopen.h" +#include "protocolSession.h" + +namespace DevDriver +{ + class Session; + + class IProtocolClient : public IProtocolSession + { + public: + virtual ~IProtocolClient() {} + + virtual Version GetSessionVersion() const = 0; + + virtual Result Connect(ClientId clientId) = 0; + virtual void Disconnect() = 0; + +#if !DD_VERSION_SUPPORTS(GPUOPEN_SESSION_INTERFACE_CLEANUP_VERSION) + virtual void Orphan() = 0; +#endif + virtual bool IsConnected() const = 0; + virtual ClientId GetRemoteClientId() const = 0; + protected: + IProtocolClient() {} + }; + +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocolServer.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocolServer.h new file mode 100644 index 000000000..afc04df86 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocolServer.h @@ -0,0 +1,54 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file protocolServer.h +* @brief Interface declaration for IProtocolServer. +*********************************************************************************************************************** +*/ + +#pragma once + +#include "gpuopen.h" +#include "protocolSession.h" + +namespace DevDriver +{ + class IMsgChannel; + class Session; + + class IProtocolServer : public IProtocolSession + { + public: + virtual ~IProtocolServer() {} + + virtual void Finalize() = 0; + + virtual bool GetSupportedVersion(Version minVersion, Version maxVersion, Version *version) const = 0; + virtual bool AcceptSession(const SharedPointer& pSession) = 0; + protected: + IProtocolServer() {} + }; + +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocolSession.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocolSession.h new file mode 100644 index 000000000..f8fdb6584 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocolSession.h @@ -0,0 +1,185 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file protocolSession.h +* @brief Interface declaration for IProtocolSession. +*********************************************************************************************************************** +*/ + +#pragma once + +#include "gpuopen.h" +#include "ddPlatform.h" +#include "util/template.h" +#include "util/sharedptr.h" + +namespace DevDriver +{ + // A container struct that can hold any protocol's payload and keep track of its size. + // Not intended for network transport. This struct is intended to help simplify code that works with variably sized payloads. + // The struct is 8 byte aligned because the internal payload field requires 8 byte alignment. + DD_ALIGNED_STRUCT(SizedPayloadContainer, 8) + { + uint32 payloadSize; + uint32 _padding; + char payload[kMaxPayloadSizeInBytes]; + + // For safety purposes we limit the CreatePayload and GetPayload methods to types that: + // + // 1. Have a standard layout, to ensure that the contents are safe to transmit across the network + // 2. Are trivially destructible, to ensure that a user doesn't construct an object and then overwrite it + // without destroying it + // 3. Small enough to fit inside the payload field of this struct + template + struct CanUseAsPayload + { + static_assert(Platform::IsStandardLayout::Value, "Type provided does not meet standard layout requirements"); + static_assert(Platform::IsTriviallyDestructible::Value, "Type provided is not trivially destructible"); + static_assert((sizeof(T) <= kMaxPayloadSizeInBytes), "Type provided is too large to fit in the container"); + + DD_STATIC_CONST bool Value = Platform::IsStandardLayout::Value && + Platform::IsTriviallyDestructible::Value && + (sizeof(T) <= kMaxPayloadSizeInBytes); + }; + + // We additionally only allow creation of a payload if the type is constructible using the arguments specified + template + struct CanCreatePayload + { + static_assert(CanUseAsPayload::Value, "Type specified cannot be used as a payload"); + static_assert(Platform::IsConstructible::Value, "Type provided cannot be constructed with the provided arguments"); + + DD_STATIC_CONST bool Value = CanUseAsPayload::Value && + Platform::IsConstructible::Value; + }; + + // Convenience function to allow in-place construction of a payload object using placement new. + template::Value>::Type> + void CreatePayload(Args&&... args) + { + // This is tremendously unsafe, but we use placement new to construct an object inside the buffer. + // Why do we do this? The big benefit is that it lets us skip having to create a temporary object + // and then copy it into this buffer. + // + // There are a couple of other ancillary benefits that are useful. The biggest is that if an object has + // a constexpr constructor it can initialize the memory using a memcpy/move instead of having to actually + // call the constructor. The other benefit is that if the constructor omits initializing memory (e.g., + // a giant data buffer) it will also skip re-initializing the memory here. This is not the case with + // when you create another instance of the object and copy it - the temporary object is almost certainly + // zero initialized, and the copy/move will result in the entire struct being copied. + + static_assert(alignof(T) <= alignof(SizedPayloadContainer), "Type provided cannot be aligned in the container"); + + new(reinterpret_cast(&payload[0])) T(Platform::Forward(args)...); + payloadSize = sizeof(T); + } + + // Convenience function to allow accessing the payload as if it was the specified type. + template::Value>::Type> + T& GetPayload() + { + return *GetPayloadPointer(&payload[0]); + } + + private: + // Convenience function to allow accessing the payload as if it was the specified type. + template::Value>::Type> + static constexpr T* GetPayloadPointer(char* DD_RESTRICT pPointer) + { + static_assert(alignof(T) <= alignof(SizedPayloadContainer), "Type provided cannot be aligned in the container"); + return (T*)(pPointer); + } + }; + + DD_CHECK_SIZE(SizedPayloadContainer, 8 + kMaxPayloadSizeInBytes); + + class IMsgChannel; + class Session; + + enum struct SessionType + { + Unknown = 0, + Client, + Server + }; + + class ISession + { + public: + virtual ~ISession() {}; + + virtual Result Send(uint32 payloadSizeInBytes, const void* pPayload, uint32 timeoutInMs) = 0; + virtual Result Receive(uint32 payloadSizeInBytes, void *pPayload, uint32 *pBytesReceived, uint32 timeoutInMs) = 0; + virtual void Shutdown(Result reason) = 0; + virtual void Close(Result reason) = 0; + +#if !DD_VERSION_SUPPORTS(GPUOPEN_SESSION_INTERFACE_CLEANUP_VERSION) + virtual void CloseSession(Result reason = Result::Error) = 0; + virtual void OrphanSession() = 0; +#endif + + virtual void* SetUserData(void *) = 0; + virtual void* GetUserData() const = 0; + virtual SessionId GetSessionId() const = 0; + virtual ClientId GetDestinationClientId() const = 0; + virtual Version GetVersion() const = 0; + + // Helper functions for working with SizedPayloadContainers and managing back-compat. + Result SendPayload(const SizedPayloadContainer& payload, uint32 timeoutInMs) + { + return Send(payload.payloadSize, payload.payload, timeoutInMs); + } + + Result ReceivePayload(SizedPayloadContainer* pPayload, uint32 timeoutInMs) + { + DD_ASSERT(pPayload != nullptr); + return Receive(sizeof(pPayload->payload), pPayload->payload, &pPayload->payloadSize, timeoutInMs); + } + + protected: + ISession() {} + }; + + class IProtocolSession + { + public: + virtual ~IProtocolSession() {} + + virtual Protocol GetProtocol() const = 0; + virtual SessionType GetType() const = 0; + virtual Version GetMinVersion() const = 0; + virtual Version GetMaxVersion() const = 0; + + virtual void SessionEstablished(const SharedPointer &pSession) = 0; + virtual void UpdateSession(const SharedPointer &pSession) = 0; + virtual void SessionTerminated(const SharedPointer &pSession, Result terminationReason) = 0; + protected: + IProtocolSession() {} + }; +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/ddGpuCrashDumpClient.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/ddGpuCrashDumpClient.h new file mode 100644 index 000000000..bc643f7fb --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/ddGpuCrashDumpClient.h @@ -0,0 +1,69 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2017-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file ddGpuCrashDumpClient.h +* @brief Class declaration for the gpu crash dump client +*********************************************************************************************************************** +*/ + +#pragma once + +#include "baseProtocolClient.h" +#include "protocols/ddGpuCrashDumpProtocol.h" + +namespace DevDriver +{ + class IMsgChannel; + + namespace TransferProtocol + { + class ServerBlock; + } + + namespace GpuCrashDumpProtocol + { + class GpuCrashDumpClient : public BaseProtocolClient + { + public: + explicit GpuCrashDumpClient(IMsgChannel* pMsgChannel); + ~GpuCrashDumpClient(); + + // Begins the gpu crash dumping process. Sends a notification to the server and starts + // transferring crash data. + // Returns Success if the process starts successfully, Rejected if the server rejects + // the crash dump and Error otherwise. + Result BeginGpuCrashDump(const void* pCrashDump, size_t crashDumpSize); + + // Ends the gpu crash dumping process. Waits for the crash dump transfer to finish. + // Returns Success if the transfer completes successfully, and Error otherwise. + Result EndGpuCrashDump(); + + private: + uint8* m_pCrashDump; + uint32 m_crashDumpSize; + uint32 m_crashDumpBytesSent; + }; + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/ddGpuCrashDumpProtocol.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/ddGpuCrashDumpProtocol.h new file mode 100644 index 000000000..d833bb706 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/ddGpuCrashDumpProtocol.h @@ -0,0 +1,123 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2017-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file ddGpuCrashDumpProtocol.h +* @brief Header file for the gpu crash dump protocol +*********************************************************************************************************************** +*/ + +#pragma once + +#include "gpuopen.h" +#include "systemProtocols.h" + +#define GPUCRASHDUMP_PROTOCOL_MAJOR_VERSION 1 +#define GPUCRASHDUMP_PROTOCOL_MINOR_VERSION 0 + +#define GPUCRASHDUMP_INTERFACE_VERSION ((GPUCRASHDUMP_INTERFACE_MAJOR_VERSION << 16) | GPUCRASHDUMP_INTERFACE_MINOR_VERSION) + +#define GPUCRASHDUMP_PROTOCOL_MINIMUM_MAJOR_VERSION 1 + +/* +*********************************************************************************************************************** +*| Version | Change Description | +*| ------- | ---------------------------------------------------------------------------------------------------------| +*| 1.0 | Initial version | +*********************************************************************************************************************** +*/ + +#define GPUCRASHDUMP_INITIAL_VERSION 1 + +namespace DevDriver +{ + namespace GpuCrashDumpProtocol + { + /////////////////////// + // GpuCrashDump Protocol + enum struct GpuCrashDumpMessage : MessageCode + { + Unknown = 0, + GpuCrashNotify, + GpuCrashAcknowledge, + GpuCrashDataChunk, + GpuCrashDataSentinel, + Count + }; + + /////////////////////// + // GpuCrashDump Constants + // @note: We currently subtract sizeof(uint32) instead of sizeof(GpuCrashDumpMessage) to work around struct packing issues. + // The compiler pads out GpuCrashDumpMessage to 4 bytes when it's included in the payload struct. + DD_STATIC_CONST Size kMaxGpuCrashDumpDataChunkSize = (kMaxPayloadSizeInBytes - sizeof(uint32)); + + /////////////////////// + // GpuCrashDump Payloads + DD_NETWORK_STRUCT(GpuCrashNotifyPayload, 4) + { + uint32 sizeInBytes; + }; + + DD_CHECK_SIZE(GpuCrashNotifyPayload, 4); + + DD_NETWORK_STRUCT(GpuCrashAcknowledgePayload, 4) + { + bool acceptedCrashDump; + char padding[3]; + }; + + DD_CHECK_SIZE(GpuCrashAcknowledgePayload, 4); + + DD_NETWORK_STRUCT(GpuCrashDataChunkPayload, 4) + { + uint8 data[kMaxGpuCrashDumpDataChunkSize]; + }; + + DD_CHECK_SIZE(GpuCrashDataChunkPayload, kMaxGpuCrashDumpDataChunkSize); + + DD_NETWORK_STRUCT(GpuCrashDataSentinelPayload, 4) + { + Result result; + }; + + DD_CHECK_SIZE(GpuCrashDataSentinelPayload, 4); + + DD_NETWORK_STRUCT(GpuCrashDumpPayload, 4) + { + GpuCrashDumpMessage command; + // pad out to 4 bytes for alignment requirements + char padding[3]; + + union + { + GpuCrashNotifyPayload notify; + GpuCrashAcknowledgePayload acknowledge; + GpuCrashDataChunkPayload dataChunk; + GpuCrashDataSentinelPayload sentinel; + }; + }; + + DD_CHECK_SIZE(GpuCrashDumpPayload, kMaxPayloadSizeInBytes); + } +} diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/ddGpuCrashDumpServer.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/ddGpuCrashDumpServer.h new file mode 100644 index 000000000..50927ea9a --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/ddGpuCrashDumpServer.h @@ -0,0 +1,85 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2017-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file ddGpuCrashDumpServer.h +* @brief Class declaration for GpuCrashDumpServer. +*********************************************************************************************************************** +*/ + +#pragma once + +#include "baseProtocolServer.h" +#include "ddGpuCrashDumpProtocol.h" +#include "util/vector.h" +#include "util/sharedptr.h" + +namespace DevDriver +{ + namespace GpuCrashDumpProtocol + { + // Abstract interface for handling crash notifications + class ICrashDumpHandler + { + public: + virtual ~ICrashDumpHandler() {} + + // Accepts or rejects a crash dump notification from an external client. + virtual bool AcceptCrashDump(size_t crashDumpSizeInBytes, ClientId clientId, void** ppUserdata) = 0; + + // Handles incoming crash dump data. Returns false if we should abort the transfer. + virtual void ReceiveCrashDumpData(const uint8* pCrashDumpData, size_t crashDumpDataSize, void* pUserdata) = 0; + + // Performs any work that should be done at the end of the transfer. + virtual void FinishCrashDumpTransfer(bool transferSuccessful, void* pUserdata) = 0; + + protected: + ICrashDumpHandler() {} + }; + + class GpuCrashDumpServer : public BaseProtocolServer + { + public: + explicit GpuCrashDumpServer(IMsgChannel* pMsgChannel); + ~GpuCrashDumpServer(); + + bool AcceptSession(const SharedPointer& pSession) override; + void SessionEstablished(const SharedPointer& pSession) override; + void UpdateSession(const SharedPointer& pSession) override; + void SessionTerminated(const SharedPointer& pSession, Result terminationReason) override; + + // Sets the current crash dump handler. + // Returns Error if the crash handler cannot currently be changed due to active sessions. + Result SetCrashDumpHandler(ICrashDumpHandler* pHandler); + + // Gets the current crash dump handler. + ICrashDumpHandler* GetCrashDumpHandler(); + + private: + Platform::Mutex m_mutex; + ICrashDumpHandler* m_pCrashDumpHandler; + uint32 m_numSessions; + }; + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/ddTransferClient.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/ddTransferClient.h new file mode 100644 index 000000000..841328295 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/ddTransferClient.h @@ -0,0 +1,126 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file ddTransferClient.h +* @brief Class declaration for TransferClient. +*********************************************************************************************************************** +*/ + +#pragma once + +#include "baseProtocolClient.h" +#include "protocols/ddTransferProtocol.h" + +namespace DevDriver +{ + class IMsgChannel; + + namespace TransferProtocol + { + class TransferClient final : public BaseProtocolClient + { + public: + explicit TransferClient(IMsgChannel* pMsgChannel); + ~TransferClient(); + + // Requests a transfer on the remote client. Returns Success if the request was successful and data + // is being sent to the client. Returns the size in bytes of the data being transferred in + // pTransferSizeInBytes. + Result RequestPullTransfer(BlockId blockId, size_t* pTransferSizeInBytes); + + // Reads transfer data from a previous transfer that completed successfully. + Result ReadPullTransferData(uint8* pDstBuffer, size_t bufferSize, size_t* pBytesRead); + + // Aborts a pull transfer in progress. + Result AbortPullTransfer(); + + // Requests a transfer on the remote client. Returns Success if the request was successful and data + // can be written to the server. + Result RequestPushTransfer(BlockId blockId, size_t transferSizeInBytes); + + // Writes transfer data to the remote server. + Result WritePushTransferData(const uint8* pSrcBuffer, size_t bufferSize); + + // Closes the push transfer session, optionally discarding any data already transmitted + Result ClosePushTransfer(bool discard = false); + + // Returns true if there's currently a transfer in progress. + bool IsTransferInProgress() const + { + return IsConnected() && (m_transferContext.state == TransferState::TransferInProgress); + } + + // Backwards compatibility + Result RequestTransfer(BlockId blockId, size_t* pTransferSizeInBytes) + { + return RequestPullTransfer(blockId, pTransferSizeInBytes); + } + + Result ReadTransferData(uint8* pDstBuffer, size_t bufferSize, size_t* pBytesRead) + { + return ReadPullTransferData(pDstBuffer, bufferSize, pBytesRead); + } + + private: + void ResetState() override; + + // Helper method to send a payload, handling backwards compatibility and retrying. + Result SendTransferPayload(const SizedPayloadContainer& container, + uint32 timeoutInMs = kDefaultCommunicationTimeoutInMs, + uint32 retryInMs = kDefaultRetryTimeoutInMs); + // Helper method to handle sending a payload from a SizedPayloadContainer, including retrying if busy. + Result ReceiveTransferPayload(SizedPayloadContainer* pContainer, + uint32 timeoutInMs = kDefaultCommunicationTimeoutInMs, + uint32 retryInMs = kDefaultRetryTimeoutInMs); + // Helper method to send and then receive using a SizedPayloadContainer object. + Result TransactTransferPayload(SizedPayloadContainer* pContainer, + uint32 timeoutInMs = kDefaultCommunicationTimeoutInMs, + uint32 retryInMs = kDefaultRetryTimeoutInMs); + + enum class TransferState : uint32 + { + Idle = 0, + TransferInProgress, + Error + }; + + // Context structure for tracking all state specific to a transfer. + struct ClientTransferContext + { + TransferState state; + TransferType type; + uint32 totalBytes; + uint32 crc32; + size_t dataChunkSizeInBytes; + size_t dataChunkBytesTransfered; + SizedPayloadContainer scratchPayload; + }; + + ClientTransferContext m_transferContext; + + DD_STATIC_CONST uint32 kTransferChunkTimeoutInMs = 3000; + }; + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/ddTransferProtocol.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/ddTransferProtocol.h new file mode 100644 index 000000000..d18301990 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/ddTransferProtocol.h @@ -0,0 +1,205 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file ddTransferProtocol.h +* @brief Protocol header for the block transfer protocol. +*********************************************************************************************************************** +*/ + +#pragma once + +#include "gpuopen.h" +#include "protocolSession.h" +#include + +/* +*********************************************************************************************************************** +* Transfer Protocol +*********************************************************************************************************************** +*/ + +#define TRANSFER_PROTOCOL_MAJOR_VERSION 2 +#define TRANSFER_PROTOCOL_MINOR_VERSION 0 + +#define TRANSFER_INTERFACE_VERSION ((TRANSFER_INTERFACE_MAJOR_VERSION << 16) | TRANSFER_INTERFACE_MINOR_VERSION) + +#define TRANSFER_PROTOCOL_MINIMUM_MAJOR_VERSION 1 + +/* +*********************************************************************************************************************** +*| Version | Change Description | +*| ------- | ---------------------------------------------------------------------------------------------------------| +*| 2.0 | Refactor for variably sized messages + push transfers | +*| 1.0 | Initial version | +*********************************************************************************************************************** +*/ + +#define TRANSFER_REFACTOR_VERSION 2 +#define TRANSFER_INITIAL_VERSION 1 + +namespace DevDriver +{ + namespace TransferProtocol + { + /////////////////////// + // GPU Open Transfer Protocol + enum struct TransferMessage : uint32 + { + Unknown = 0, + TransferRequest, + TransferDataHeader, + TransferDataChunk, + TransferDataSentinel, + TransferStatus, + Count, + }; + + enum struct TransferType : uint32 + { + Pull = 0, + Push, + Count, + }; + + // @note: We currently subtract sizeof(uint32) instead of sizeof(TransferMessage) to work around struct packing issues. + // The compiler pads out TransferMessage to 4 bytes when it's included in the payload struct. + DD_STATIC_CONST size_t kMaxTransferDataChunkSize = (kMaxPayloadSizeInBytes - sizeof(uint32)); + + /////////////////////// + // Transfer Types + typedef uint32 BlockId; + DD_STATIC_CONST BlockId kInvalidBlockId = 0; + + /////////////////////// + // Transfer Payloads + + DD_NETWORK_STRUCT(TransferHeader, 4) + { + TransferMessage command; + constexpr TransferHeader(TransferMessage message = TransferMessage::Unknown) + : command(message) + { + } + }; + + DD_CHECK_SIZE(TransferHeader, 4); + + DD_NETWORK_STRUCT(TransferRequest, 4) + { + TransferMessage command; + BlockId blockId; + TransferType type; + uint32 sizeInBytes; + + constexpr TransferRequest(BlockId blockId, TransferType type, uint32 size) + : command(TransferMessage::TransferRequest) + , blockId(blockId) + , type(type) + , sizeInBytes(size) + { + } + }; + + DD_CHECK_SIZE(TransferRequest, 16); + + DD_NETWORK_STRUCT(TransferDataHeader, 4) + { + TransferMessage command; + Result result; + uint32 sizeInBytes; + + constexpr TransferDataHeader(Result result, uint32 size) + : command(TransferMessage::TransferDataHeader) + , result(result) + , sizeInBytes(size) + { + } + }; + + DD_CHECK_SIZE(TransferDataHeader, 12); + + DD_NETWORK_STRUCT(TransferDataHeaderV2, 4) + { + TransferMessage command; + uint32 sizeInBytes; + + constexpr TransferDataHeaderV2(uint32 size) + : command(TransferMessage::TransferDataHeader) + , sizeInBytes(size) + {} + }; + + DD_CHECK_SIZE(TransferDataHeaderV2, 8); + + DD_NETWORK_STRUCT(TransferDataChunk, 4) + { + TransferMessage command; + uint8 data[kMaxTransferDataChunkSize]; + + static void WritePayload( + const void *pData, + size_t bytesToSend, + SizedPayloadContainer* pContainer) + { + pContainer->payloadSize = static_cast(bytesToSend + offsetof(TransferDataChunk, data)); + DD_ASSERT(pContainer->payloadSize <= kMaxPayloadSizeInBytes); + TransferDataChunk& payload = pContainer->GetPayload(); + payload.command = TransferMessage::TransferDataChunk; + memcpy(&payload.data[0], pData, bytesToSend); + } + }; + + DD_CHECK_SIZE(TransferDataChunk, kMaxPayloadSizeInBytes); + + DD_NETWORK_STRUCT(TransferDataSentinel, 4) + { + TransferMessage command; + Result result; + uint32 crc32; + + constexpr TransferDataSentinel(Result result, uint32 crc32) + : command(TransferMessage::TransferDataSentinel) + , result(result) + , crc32(crc32) + { + } + }; + + DD_CHECK_SIZE(TransferDataSentinel, 12); + + DD_NETWORK_STRUCT(TransferStatus, 4) + { + TransferMessage command; + Result result; + + constexpr TransferStatus(Result result) + : command(TransferMessage::TransferStatus) + , result(result) + {} + }; + + DD_CHECK_SIZE(TransferStatus, 8); + } +} diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/ddTransferServer.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/ddTransferServer.h new file mode 100644 index 000000000..1113bbf52 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/ddTransferServer.h @@ -0,0 +1,61 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file ddTransferServer.h +* @brief Class declaration for TransferServer. +*********************************************************************************************************************** +*/ + +#pragma once + +#include "baseProtocolServer.h" +#include "protocols/ddTransferProtocol.h" + +namespace DevDriver +{ + namespace TransferProtocol + { + class TransferManager; + + // The protocol server implementation for the transfer protocol. + class TransferServer final : public BaseProtocolServer + { + public: + explicit TransferServer(IMsgChannel* pMsgChannel, TransferManager* pTransferManager); + ~TransferServer(); + + void Finalize() override; + + bool AcceptSession(const SharedPointer& pSession) override; + void SessionEstablished(const SharedPointer& pSession) override; + void UpdateSession(const SharedPointer& pSession) override; + void SessionTerminated(const SharedPointer& pSession, Result terminationReason) override; + private: + TransferManager* m_pTransferManager; + + class TransferSession; + }; + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/ddURIClient.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/ddURIClient.h new file mode 100644 index 000000000..a9e25bdf7 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/ddURIClient.h @@ -0,0 +1,90 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file ddURIClient.h +* @brief Class declaration for URIClient. +*********************************************************************************************************************** +*/ + +#pragma once + +#include "baseProtocolClient.h" +#include "ddUriInterface.h" + +namespace DevDriver +{ + class IMsgChannel; + + namespace TransferProtocol + { + class PullBlock; + } + + namespace URIProtocol + { + // We alias these types for backwards compatibility + using ResponseHeader = DevDriver::URIResponseHeader; + + class URIClient final : public BaseProtocolClient + { + public: + explicit URIClient(IMsgChannel* pMsgChannel); + ~URIClient(); + + // Sends a URI request to the connected server. + Result RequestURI(const char* pRequestString, ResponseHeader* pResponseHeader = nullptr); + +#if !DD_VERSION_SUPPORTS(GPUOPEN_URI_RESPONSE_FORMATS_VERSION) + // Sends a URI request to the connected server. + // Deprecated + Result RequestURI(const char* pRequestString, size_t* pResponseSizeInBytes); +#endif + + // Reads response data that was returned by a prior request. + Result ReadResponse(uint8* pDstBuffer, size_t bufferSize, size_t* pBytesRead); + + // Aborts the currently active request. + Result AbortRequest(); + + private: + void ResetState() override; + + enum class State : uint32 + { + Idle = 0, + ReadResponse + }; + + // Context structure for tracking all state specific to a request. + struct Context + { + State state; + TransferProtocol::PullBlock* pBlock; + }; + + Context m_context; + }; + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/ddURIProtocol.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/ddURIProtocol.h new file mode 100644 index 000000000..ba75a79e4 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/ddURIProtocol.h @@ -0,0 +1,122 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file ddURIProtocol.h +* @brief Protocol header for the URI protocol. +*********************************************************************************************************************** +*/ + +#pragma once + +#include "gpuopen.h" +#include "ddTransferProtocol.h" + +/* +*********************************************************************************************************************** +* URI Protocol +*********************************************************************************************************************** +*/ + +#define URI_PROTOCOL_MAJOR_VERSION 2 +#define URI_PROTOCOL_MINOR_VERSION 0 + +#define URI_INTERFACE_VERSION ((URI_INTERFACE_MAJOR_VERSION << 16) | URI_INTERFACE_MINOR_VERSION) + +#define URI_PROTOCOL_MINIMUM_MAJOR_VERSION 1 + +/* +*********************************************************************************************************************** +*| Version | Change Description | +*| ------- | ---------------------------------------------------------------------------------------------------------| +*| 2.0 | Added support for response data formats. | +*| 1.0 | Initial version | +*********************************************************************************************************************** +*/ + +#define URI_RESPONSE_FORMATS_VERSION 2 +#define URI_INITIAL_VERSION 1 + +namespace DevDriver +{ + namespace URIProtocol + { + /////////////////////// + // GPU Open URI Protocol + enum struct URIMessage : MessageCode + { + Unknown = 0, + URIRequest, + URIResponse, + Count, + }; + + /////////////////////// + // URI Types + enum struct ResponseDataFormat : uint32 + { + Unknown = 0, + Text, + Binary, + Count + }; + + /////////////////////// + // URI Constants + DD_STATIC_CONST uint32 kURIStringSize = 256; + + /////////////////////// + // URI Payloads + + DD_NETWORK_STRUCT(URIRequestPayload, 4) + { + char uriString[kURIStringSize]; + }; + + DD_CHECK_SIZE(URIRequestPayload, kURIStringSize); + + DD_NETWORK_STRUCT(URIResponsePayload, 4) + { + Result result; + TransferProtocol::BlockId blockId; + ResponseDataFormat format; // format is only valid in v2 sessions or higher. + }; + + DD_CHECK_SIZE(URIResponsePayload, 12); + + DD_NETWORK_STRUCT(URIPayload, 4) + { + URIMessage command; + // pad out to 4 bytes for alignment requirements + char padding[3]; + union + { + URIRequestPayload uriRequest; + URIResponsePayload uriResponse; + }; + }; + + DD_CHECK_SIZE(URIPayload, 260); + } +} diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/ddURIService.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/ddURIService.h new file mode 100644 index 000000000..ac669f5fa --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/ddURIService.h @@ -0,0 +1,69 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file ddURIService.h +* @brief Class declaration for URIService. +*********************************************************************************************************************** +*/ + +#pragma once + +#include "gpuopen.h" +#include "ddPlatform.h" +#include "ddUriInterface.h" +#include "util/sharedptr.h" +#include "ddTransferManager.h" + +namespace DevDriver +{ + namespace URIProtocol + { + // We alias these types for backwards compatibility + using URIRequestContext = DevDriver::URIRequestContext; + using ResponseDataFormat = DevDriver::URIDataFormat; + + // Base class for URI services + class URIService : public IService + { + public: + virtual ~URIService() {} + + // Returns the name of the service + const char* GetName() const override final { return m_name; } + + protected: + URIService(const char* pName) + { + // Copy the service name into a member variable for later use. + Platform::Strncpy(m_name, pName, sizeof(m_name)); + } + + DD_STATIC_CONST uint32 kServiceNameSize = 64; + + // The name of the service + char m_name[kServiceNameSize]; + }; + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/driverControlClient.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/driverControlClient.h new file mode 100644 index 000000000..469025faf --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/driverControlClient.h @@ -0,0 +1,80 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file driverControlClient.h +* @brief Developer Driver Control Client Interface +*********************************************************************************************************************** +*/ + +#pragma once + +#include "baseProtocolClient.h" +#include "protocols/driverControlProtocol.h" + +namespace DevDriver +{ + class IMsgChannel; + + namespace DriverControlProtocol + { + class DriverControlClient : public BaseProtocolClient + { + public: + explicit DriverControlClient(IMsgChannel* pMsgChannel); + ~DriverControlClient(); + + // Pauses execution inside the driver + Result PauseDriver(); + + // Resumes execution inside the driver + Result ResumeDriver(); + + Result StepDriver(uint32 numSteps); + + // Returns the number of gpus the driver is managing. + Result QueryNumGpus(uint32* pNumGpus); + + // Returns the current device clock mode + Result QueryDeviceClockMode(uint32 gpuIndex, DeviceClockMode* pClockMode); + + // Sets the current device clock mode + Result SetDeviceClockMode(uint32 gpuIndex, DeviceClockMode clockMode); + + // Returns the current device clock values in MHz + Result QueryDeviceClock(uint32 gpuIndex, float* pGpuClock, float* pMemClock); + + // Returns the max device clock values in MHz + Result QueryMaxDeviceClock(uint32 gpuIndex, float* pMaxGpuClock, float* pMaxMemClock); + + // Returns the current status of the driver. + Result QueryDriverStatus(DriverStatus* pDriverStatus); + + // Waits until the driver finishes initialization. + Result WaitForDriverInitialization(uint32 timeoutInMs); + + private: + }; + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/driverControlProtocol.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/driverControlProtocol.h new file mode 100644 index 000000000..e0e75f48a --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/driverControlProtocol.h @@ -0,0 +1,235 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#pragma once + +#include "gpuopen.h" + +#define DRIVERCONTROL_PROTOCOL_MAJOR_VERSION 2 +#define DRIVERCONTROL_PROTOCOL_MINOR_VERSION 0 + +#define DRIVERCONTROL_INTERFACE_VERSION ((DRIVERCONTROL_INTERFACE_MAJOR_VERSION << 16) | DRIVERCONTROL_INTERFACE_MINOR_VERSION) + +#define DRIVERCONTROL_PROTOCOL_MINIMUM_MAJOR_VERSION 1 + +/* +*********************************************************************************************************************** +*| Version | Change Description | +*| ------- | ---------------------------------------------------------------------------------------------------------| +*| 2.0 | Added initialization time driver status values and a terminate driver command. | +*| 1.0 | Initial version | +*********************************************************************************************************************** +*/ + +#define DRIVERCONTROL_INITIALIZATION_STATUS_VERSION 2 +#define DRIVERCONTROL_INITIAL_VERSION 1 + +namespace DevDriver +{ + namespace DriverControlProtocol + { + /////////////////////// + // DriverControl Protocol + enum struct DriverControlMessage : MessageCode + { + Unknown = 0, + PauseDriverRequest, + PauseDriverResponse, + ResumeDriverRequest, + ResumeDriverResponse, + QueryNumGpusRequest, + QueryNumGpusResponse, + QueryDeviceClockModeRequest, + QueryDeviceClockModeResponse, + SetDeviceClockModeRequest, + SetDeviceClockModeResponse, + QueryDeviceClockRequest, + QueryDeviceClockResponse, + QueryMaxDeviceClockRequest, + QueryMaxDeviceClockResponse, + QueryDriverStatusRequest, + QueryDriverStatusResponse, + StepDriverRequest, + StepDriverResponse, + Count + }; + + /////////////////////// + // DriverControl Types + enum struct DeviceClockMode : uint32 + { + Unknown = 0, + Default, + Profiling, + MinimumMemory, + MinimumEngine, + Peak, + Count + }; + + enum struct DriverStatus : uint32 + { + Running = 0, + Paused, + HaltedOnStart, + EarlyInit, + LateInit, + Count + }; + + /////////////////////// + // DriverControl Payloads + DD_NETWORK_STRUCT(PauseDriverResponsePayload, 4) + { + Result result; + }; + + DD_CHECK_SIZE(PauseDriverResponsePayload, 4); + + DD_NETWORK_STRUCT(ResumeDriverResponsePayload, 4) + { + Result result; + }; + + DD_CHECK_SIZE(ResumeDriverResponsePayload, 4); + + DD_NETWORK_STRUCT(QueryNumGpusResponsePayload, 4) + { + Result result; + uint32 numGpus; + }; + + DD_CHECK_SIZE(QueryNumGpusResponsePayload, 8); + + DD_NETWORK_STRUCT(QueryDeviceClockModeRequestPayload, 4) + { + uint32 gpuIndex; + }; + + DD_CHECK_SIZE(QueryDeviceClockModeRequestPayload, 4); + + DD_NETWORK_STRUCT(QueryDeviceClockModeResponsePayload, 4) + { + Result result; + DeviceClockMode mode; + }; + + DD_CHECK_SIZE(QueryDeviceClockModeResponsePayload, 8); + + DD_NETWORK_STRUCT(SetDeviceClockModeRequestPayload, 4) + { + uint32 gpuIndex; + DeviceClockMode mode; + }; + + DD_CHECK_SIZE(SetDeviceClockModeRequestPayload, 8); + + DD_NETWORK_STRUCT(SetDeviceClockModeResponsePayload, 4) + { + Result result; + }; + + DD_CHECK_SIZE(SetDeviceClockModeResponsePayload, 4); + + DD_NETWORK_STRUCT(QueryDeviceClockRequestPayload, 4) + { + uint32 gpuIndex; + }; + + DD_CHECK_SIZE(QueryDeviceClockRequestPayload, 4); + + DD_NETWORK_STRUCT(QueryDeviceClockResponsePayload, 4) + { + Result result; + float gpuClock; + float memClock; + }; + + DD_CHECK_SIZE(QueryDeviceClockResponsePayload, 12); + + DD_NETWORK_STRUCT(QueryMaxDeviceClockRequestPayload, 4) + { + uint32 gpuIndex; + }; + + DD_CHECK_SIZE(QueryMaxDeviceClockRequestPayload, 4); + + DD_NETWORK_STRUCT(QueryMaxDeviceClockResponsePayload, 4) + { + Result result; + float maxGpuClock; + float maxMemClock; + }; + + DD_CHECK_SIZE(QueryMaxDeviceClockResponsePayload, 12); + + DD_NETWORK_STRUCT(QueryDriverStatusResponsePayload, 4) + { + DriverStatus status; + }; + + DD_CHECK_SIZE(QueryDriverStatusResponsePayload, 4); + + DD_NETWORK_STRUCT(StepDriverRequestPayload, 4) + { + uint32 count; + }; + + DD_CHECK_SIZE(StepDriverRequestPayload, 4); + + DD_NETWORK_STRUCT(StepDriverResponsePayload, 4) + { + Result result; + }; + + DD_CHECK_SIZE(StepDriverResponsePayload, 4); + + DD_NETWORK_STRUCT(DriverControlPayload, 4) + { + DriverControlMessage command; + // pad out to 4 bytes for alignment requirements + char padding[3]; + + union + { + PauseDriverResponsePayload pauseDriverResponse; + ResumeDriverResponsePayload resumeDriverResponse; + QueryNumGpusResponsePayload queryNumGpusResponse; + QueryDeviceClockModeRequestPayload queryDeviceClockModeRequest; + QueryDeviceClockModeResponsePayload queryDeviceClockModeResponse; + SetDeviceClockModeRequestPayload setDeviceClockModeRequest; + SetDeviceClockModeResponsePayload setDeviceClockModeResponse; + QueryDeviceClockRequestPayload queryDeviceClockRequest; + QueryDeviceClockResponsePayload queryDeviceClockResponse; + QueryMaxDeviceClockResponsePayload queryMaxDeviceClockResponse; + QueryMaxDeviceClockRequestPayload queryMaxDeviceClockRequest; + QueryDriverStatusResponsePayload queryDriverStatusResponse; + StepDriverRequestPayload stepDriverRequest; + StepDriverResponsePayload stepDriverResponse; + }; + }; + + DD_CHECK_SIZE(DriverControlPayload, 16); + } +} diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/driverControlServer.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/driverControlServer.h new file mode 100644 index 000000000..1188ee218 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/driverControlServer.h @@ -0,0 +1,101 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file driverControlServer.h +* @brief Class declaration for DriverControlServer. +*********************************************************************************************************************** +*/ + +#pragma once + +#include "baseProtocolServer.h" +#include "driverControlProtocol.h" + +namespace DevDriver +{ + namespace DriverControlProtocol + { + DD_STATIC_CONST uint32 kMaxNumGpus = 16; + + typedef Result(*QueryDeviceClockCallback)(uint32 gpuIndex, float* pGpuClock, float* pMemClock, void* pUserdata); + typedef Result(*QueryMaxDeviceClockCallback)(uint32 gpuIndex, float* pMaxGpuClock, float* pMaxMemClock, void* pUserdata); + typedef Result(*SetDeviceClockModeCallback)(uint32 gpuIndex, DeviceClockMode clockMode, void* pUserdata); + + struct DeviceClockCallbackInfo + { + QueryDeviceClockCallback queryClockCallback; + QueryMaxDeviceClockCallback queryMaxClockCallback; + SetDeviceClockModeCallback setCallback; + void* pUserdata; + }; + + class DriverControlServer : public BaseProtocolServer + { + public: + explicit DriverControlServer(IMsgChannel* pMsgChannel); + ~DriverControlServer(); + + void Finalize() override; + + bool AcceptSession(const SharedPointer& pSession) override; + void SessionEstablished(const SharedPointer& pSession) override; + void UpdateSession(const SharedPointer& pSession) override; + void SessionTerminated(const SharedPointer& pSession, Result terminationReason) override; + + void WaitForDriverResume(); + + bool IsDriverInitialized() const; + void FinishDriverInitialization(); + + DriverStatus QueryDriverStatus(); + + void PauseDriver(); + void ResumeDriver(); + + void SetNumGpus(uint32 numGpus); + void SetDeviceClockCallback(const DeviceClockCallbackInfo& deviceClockCallbackInfo); + + uint32 GetNumGpus(); + DeviceClockMode GetDeviceClockMode(uint32 gpuIndex); + + private: + void LockData(); + void UnlockData(); + void WaitForDriverStart(uint64 timeoutInMs); + + Platform::Mutex m_mutex; + DriverStatus m_driverStatus; + Platform::Event m_driverResumedEvent; + + uint32 m_numGpus; + DeviceClockMode m_deviceClockModes[kMaxNumGpus]; + DeviceClockCallbackInfo m_deviceClockCallbackInfo; + Platform::Atomic m_numSessions; + Platform::Atomic m_stepCounter; + + DD_STATIC_CONST uint32 kBroadcastIntervalInMs = 100; + }; + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/etwClient.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/etwClient.h new file mode 100644 index 000000000..46692689d --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/etwClient.h @@ -0,0 +1,63 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file etwClient.h +* @brief Class declaration for ETWClient. +*********************************************************************************************************************** +*/ + +#pragma once + +#include "baseProtocolClient.h" +#include "protocols/etwProtocol.h" + +namespace DevDriver +{ + class IMsgChannel; + + namespace ETWProtocol + { + enum class SessionState + { + Idle = 0, + Tracing, + Waiting, + Receiving, + }; + + class ETWClient : public BaseProtocolClient + { + public: + explicit ETWClient(IMsgChannel* pMsgChannel); + ~ETWClient(); + Result EnableTracing(ProcessId processId); + Result DisableTracing(size_t *pNumEvents); + Result GetTraceData(GpuEvent *buffer, size_t numEvents); + private: + SessionState m_sessionState; + }; + + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/etwProtocol.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/etwProtocol.h new file mode 100644 index 000000000..bbe0c290d --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/etwProtocol.h @@ -0,0 +1,175 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file etwProtcol.h +* @brief Common interface for ETW Protocol. +*********************************************************************************************************************** +*/ + +#pragma once + +#include "gpuopen.h" + +namespace DevDriver +{ + enum struct GpuEventType : uint16 + { + Unknown = 0, + QueueSignal, + QueueWait, + Count + }; + + DD_NETWORK_STRUCT(GpuEvent, 8) + { + uint64 submissionTime; + uint64 completionTime; + GpuEventType type; + uint8 reserved[6]; + union + { + struct + { + uint64 contextIdentifier; + uint64 fenceObject; + uint64 fenceValue; + } queue; + }; + }; + + DD_CHECK_SIZE(GpuEvent, 48); + + namespace ETWProtocol + { + /////////////////////// + // ETW Protocol + enum struct ETWMessage : MessageCode + { + Unknown = 0, + BeginTrace, + BeginResponse, + EndTrace, + EndResponse, + TraceDataChunk, + TraceDataSentinel, + Count + }; + + /////////////////////// + // ETW Constants + DD_STATIC_CONST Version kVersion = 3; + + // @note: We currently subtract sizeof(uint32) instead of sizeof(ETWMessage) to work around struct packing issues. + // The compiler pads out ETWMessage to 4 bytes when it's included in the payload struct. It also pads out + // the TraceDataChunk data field to 1000 bytes. This causes the total payload size to be 1004 bytes which is + // 4 bytes larger than the maximum size allowed. + static const Size kMaxTraceDataChunkSize = (kMaxPayloadSizeInBytes - sizeof(uint32) - sizeof(uint32)); + + /////////////////////// + // ETW Types + DD_NETWORK_STRUCT(StartTraceRequestPayload, 4) + { + ProcessId processId; + }; + + DD_CHECK_SIZE(StartTraceRequestPayload, 4); + + DD_NETWORK_STRUCT(StartTraceResponsePayload, 4) + { + Result result; + }; + + DD_CHECK_SIZE(StartTraceResponsePayload, 4); + + DD_NETWORK_STRUCT(StopTraceRequestPayload, 4) + { + uint8 discard; + uint8 reserved[3]; + }; + + DD_CHECK_SIZE(StopTraceRequestPayload, 4); + + DD_NETWORK_STRUCT(StopTraceResponsePayload, 4) + { + Result result; + uint32 numEventsCaptured; + }; + + DD_CHECK_SIZE(StopTraceResponsePayload, 8); + + DD_NETWORK_STRUCT(TraceDataChunk, 4) + { + uint32 dataSize; + uint8 data[kMaxTraceDataChunkSize]; + }; + + DD_STATIC_CONST uint32 kTraceChunkAlignmentSize = 8; + DD_STATIC_CONST uint32 kMaxEventsPerChunk = (kMaxPayloadSizeInBytes - kTraceChunkAlignmentSize * 2)/sizeof(GpuEvent); + + DD_NETWORK_STRUCT(TraceDataChunkPayload, kTraceChunkAlignmentSize) + { + uint16 numEvents; + uint8 reserved[kTraceChunkAlignmentSize - sizeof(uint16)]; + GpuEvent events[kMaxEventsPerChunk]; + }; + + DD_CHECK_SIZE(TraceDataChunkPayload, (sizeof(GpuEvent) * kMaxEventsPerChunk) + offsetof(TraceDataChunkPayload, events)); + + DD_NETWORK_STRUCT(TraceDataSentinelPayload, 4) + { + Result result; + }; + + DD_CHECK_SIZE(TraceDataSentinelPayload, 4); + + enum struct ProfilingStatus : uint32 + { + NotAvailable = 0, + Available, + Enabled, + Count + }; + + /////////////////////// + // ETW Payloads + DD_NETWORK_STRUCT(ETWPayload, 8) + { + ETWMessage command; + // pad out to 4 bytes for alignment requirements + char padding[7]; + union + { + StartTraceRequestPayload startTrace; + StartTraceResponsePayload startTraceResponse; + StopTraceRequestPayload stopTrace; + StopTraceResponsePayload stopTraceResponse; + TraceDataChunkPayload traceDataChunk; + TraceDataSentinelPayload traceDataSentinel; + }; + }; + + DD_CHECK_SIZE(ETWPayload, 1360); + } +} diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/etwServer.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/etwServer.h new file mode 100644 index 000000000..feb783aaa --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/etwServer.h @@ -0,0 +1,54 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file etwServer.h +* @brief Class declaration for ETWServer. +*********************************************************************************************************************** +*/ + +#pragma once + +#include "baseProtocolServer.h" +#include "etwProtocol.h" + +namespace DevDriver +{ + namespace ETWProtocol + { + class ETWServer : public BaseProtocolServer + { + public: + explicit ETWServer(IMsgChannel* pMsgChannel); + ~ETWServer(); + + void Finalize() override; + bool AcceptSession(const SharedPointer& pSession) override; + void SessionEstablished(const SharedPointer& pSession) override; + void UpdateSession(const SharedPointer& pSession) override; + void SessionTerminated(const SharedPointer& pSession, Result terminationReason) override; + private: + }; + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/loggingClient.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/loggingClient.h new file mode 100644 index 000000000..648121f86 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/loggingClient.h @@ -0,0 +1,94 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#pragma once + +#include "baseProtocolClient.h" +#include "loggingProtocol.h" +#include "util/queue.h" +#include "util/vector.h" + +namespace DevDriver +{ + class IMsgChannel; + + namespace LoggingProtocol + { + enum class LoggingClientState : uint32 + { + Idle = 0, + Logging, + LoggingFinished + }; + + class LoggingClient : public BaseProtocolClient + { + public: + explicit LoggingClient(IMsgChannel* pMsgChannel); + ~LoggingClient(); + + // Overrides the base client's update session functionality + void UpdateSession(const SharedPointer& pSession) override final; + + // Overrides the base client's session termination callback to ensure state gets reset + void SessionTerminated(const SharedPointer& pSession, Result terminationReason) override final; + + // Sends an enable logging message to the UMD + Result EnableLogging(LogLevel priority, LoggingCategory categoryMask); + + // Sends a disable logging message to the UMD + Result DisableLogging(); + + // Queries available categories and populates the provided vector + Result QueryCategories(Vector &categories); + + // Reads the log messages stored on the remote server into the provided vector + Result ReadLogMessages(Vector &logMessages); + + // Returns true if the client currently contains log messages that have not been received. + bool HasLogMessages(); + + private: + void ResetState() override; + + bool IsIdle() const; + bool IsLogging() const; + + Result SendLoggingPayload(const SizedPayloadContainer& container, + uint32 timeoutInMs = kDefaultCommunicationTimeoutInMs, + uint32 retryInMs = kDefaultRetryTimeoutInMs); + Result ReceiveLoggingPayload(SizedPayloadContainer* pContainer, + uint32 timeoutInMs = kDefaultCommunicationTimeoutInMs, + uint32 retryInMs = kDefaultRetryTimeoutInMs); + Result TransactLoggingPayload(SizedPayloadContainer* pContainer, + uint32 timeoutInMs = kDefaultCommunicationTimeoutInMs, + uint32 retryInMs = kDefaultRetryTimeoutInMs); + + LoggingClientState m_loggingState; + Queue m_logMessages; + Platform::Mutex m_mutex; + Platform::Event m_loggingFinishedEvent; + }; + } +} diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/loggingProtocol.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/loggingProtocol.h new file mode 100644 index 000000000..64aceee3c --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/loggingProtocol.h @@ -0,0 +1,303 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#pragma once + +#include "gpuopen.h" +#include + +#define LOGGING_PROTOCOL_MAJOR_VERSION 3 +#define LOGGING_PROTOCOL_MINOR_VERSION 0 + +#define LOGGING_INTERFACE_VERSION ((LOGGING_INTERFACE_MAJOR_VERSION << 16) | LOGGING_INTERFACE_MINOR_VERSION) + +#define LOGGING_PROTOCOL_MINIMUM_MAJOR_VERSION 1 + +/* +*********************************************************************************************************************** +*| Version | Change Description | +*| ------- | ---------------------------------------------------------------------------------------------------------| +*| 3.0 | Variably sized log message support | +*| 2.0 | Refactor to simplify protocol + API semantics | +*| 1.0 | Initial version | +*********************************************************************************************************************** +*/ + +#define LOGGING_LARGE_MESSAGES_VERSION 3 +#define LOGGING_REFACTOR_VERSION 2 +#define LOGGING_INITIAL_VERSION 1 + +namespace DevDriver +{ + + namespace LoggingProtocol + { + /////////////////////// + // Logging Constants + DD_STATIC_CONST uint32 kLegacyLoggingPayloadSize = 152; + + // Subtract the logging header size from the max payload size to get the max size for any logging payload. + DD_STATIC_CONST uint32 kLoggingHeaderSize = sizeof(uint64); + DD_STATIC_CONST uint32 kMaxLoggingPayloadSize = (kMaxPayloadSizeInBytes - kLoggingHeaderSize); + + /////////////////////// + // Logging Protocol + enum struct LoggingMessage : uint32 + { + Unknown = 0, + EnableLoggingRequest, + EnableLoggingResponse, + DisableLogging, + QueryCategoriesRequest, + QueryCategoriesNumResponse, + QueryCategoriesDataResponse, + LogMessage, + LogMessageSentinel, + Count + }; + + /////////////////////// + // Logging Types + typedef uint64 LoggingCategory; + + // WARNING: Do not increase this without also changing the payload size. + DD_STATIC_CONST uint32 kMaxCategoryCount = 64; + DD_STATIC_CONST uint32 kMaxCategoryIndex = (kMaxCategoryCount - 1); + DD_STATIC_CONST LoggingCategory kAllLoggingCategories = static_cast(-1); + + // offset definition for the default categories. + // we are reserving a total of four, giving us two we can use in the future + enum DefaultCategories : LoggingCategory + { + kGeneralCategoryOffset, + kSystemCategoryOffset, + kReservedOffset1, + kReservedOffset2, + kReservedCategoryCount + }; + + // define categories that are available to client applications + DD_STATIC_CONST uint32 kDefinableCategoryCount = kMaxCategoryCount - kReservedCategoryCount; + DD_STATIC_CONST LoggingCategory kDefinableCategoryMask = ((LoggingCategory)1 << kDefinableCategoryCount) - 1; + + static_assert(kDefinableCategoryCount <= kMaxCategoryCount, "Invalid kReservedCategoryCount"); + // ensure that the available logging category mask is wholly contained inside the all category mask + static_assert((kDefinableCategoryMask & kAllLoggingCategories) == kDefinableCategoryMask, + "Invalid category masks defined"); + + // define the default category masks start so that the first mask is outside of the kDefinableCategoryMask + enum BaseCategoryMasks : LoggingCategory + { + kGeneralCategoryMask = ((LoggingCategory)1 << (kDefinableCategoryCount + kGeneralCategoryOffset)), + kSystemCategoryMask = ((LoggingCategory)1 << (kDefinableCategoryCount + kSystemCategoryOffset)) + }; + + // test to make sure that the base logging category bitmasks are contained inside the all logging category mask + static_assert((kAllLoggingCategories & kGeneralCategoryMask) == kGeneralCategoryMask, + "Invalid category masks defined"); + static_assert((kAllLoggingCategories & kSystemCategoryMask) == kSystemCategoryMask, + "Invalid category masks defined"); + + // ensure that the base logging categories do not overlap with the available logging category mask + static_assert((kDefinableCategoryMask & kGeneralCategoryMask) == 0, "Invalid category masks defined"); + static_assert((kDefinableCategoryMask & kSystemCategoryMask) == 0, "Invalid category masks defined"); + + // A logging category is defined as both a bitmask + a name + DD_NETWORK_STRUCT(NamedLoggingCategory, 8) + { + LoggingCategory category; + char name[kMaxLoggingPayloadSize - sizeof(LoggingCategory)]; + }; + + DD_CHECK_SIZE(NamedLoggingCategory, kMaxLoggingPayloadSize); + + // ensure that we cannot define more categories than we have bits more + static_assert(kMaxCategoryCount <= 64, "kMaxCategoryCount is too big to fit inside the payload."); + + // logging filter definition + // TODO: consider replacing this with manual bitshifting + DD_NETWORK_STRUCT(LoggingFilter, 8) + { + LoggingCategory category; + uint8 reserved[7]; + LogLevel priority; + }; + + DD_CHECK_SIZE(LoggingFilter, 16); + + // logging message definition. Filter is included so the client can identify the message. + DD_NETWORK_STRUCT(LogMessage, 8) + { + LoggingFilter filter; + char message[kMaxLoggingPayloadSize - sizeof(LoggingFilter)]; + }; + + DD_CHECK_SIZE(LogMessage, kMaxLoggingPayloadSize); + + /////////////////////// + // Logging Payloads + DD_NETWORK_STRUCT(LoggingHeader, 4) + { + LoggingMessage command; + // Padding for backwards compatibility. Initial protocol defined struct as 8 byte aligned, so first 8 bytes + // were always used for the header. We mark this as char to prevent the compiler from initializing this. + char _padding[4]; + + constexpr LoggingHeader(LoggingMessage message) + : command(message) + , _padding() + { + } + }; + + DD_CHECK_SIZE(LoggingHeader, 8); + + static_assert(sizeof(LoggingHeader) == kLoggingHeaderSize, "Logging header size mismatch!"); + + DD_NETWORK_STRUCT(EnableLoggingRequestPayload, 8) + { + LoggingHeader header; + LoggingFilter filter; + + constexpr EnableLoggingRequestPayload(const LoggingFilter& initialFilter) + : header(LoggingMessage::EnableLoggingRequest) + , filter(initialFilter) + { + } + }; + + DD_CHECK_SIZE(EnableLoggingRequestPayload, sizeof(LoggingHeader) + sizeof(LoggingFilter)); + + DD_NETWORK_STRUCT(EnableLoggingResponsePayload, 4) + { + LoggingHeader header; + Result result; + // Padding for backwards compatibility. Should remove on version bump. + char _padding[4]; + + constexpr EnableLoggingResponsePayload(Result response) + : header(LoggingMessage::EnableLoggingResponse) + , result(response) + , _padding() + { + } + }; + + DD_CHECK_SIZE(EnableLoggingResponsePayload, sizeof(LoggingHeader) + 8); + + DD_NETWORK_STRUCT(QueryCategoriesNumResponsePayload, 4) + { + LoggingHeader header; + uint32 numCategories; + // Padding for backwards compatibility. Should remove on version bump. + char _padding[4]; + + constexpr QueryCategoriesNumResponsePayload(uint32 categories) + : header(LoggingMessage::QueryCategoriesNumResponse) + , numCategories(categories) + , _padding() + { + } + }; + + DD_CHECK_SIZE(QueryCategoriesNumResponsePayload, sizeof(LoggingHeader) + 8); + + DD_NETWORK_STRUCT(QueryCategoriesDataResponsePayload, 8) + { + LoggingHeader header; + NamedLoggingCategory category; + + static void WritePayload( + const NamedLoggingCategory& category, + Version sessionVersion, + size_t categoryNameSize, + SizedPayloadContainer* pContainer) + { + DD_ASSERT(pContainer != nullptr); + const size_t maxNameSize = + (sessionVersion >= LOGGING_LARGE_MESSAGES_VERSION) ? sizeof(category.name) : kMaxStringLength; + const size_t finalNameSize = Platform::Min(categoryNameSize, maxNameSize); + const uint32 payloadSize = + static_cast(offsetof(QueryCategoriesDataResponsePayload, category.name) + finalNameSize); + + pContainer->payloadSize = payloadSize; + + QueryCategoriesDataResponsePayload& payload = + pContainer->GetPayload(); + payload.header = LoggingHeader(LoggingMessage::QueryCategoriesDataResponse); + + memcpy(&payload.category, + &category, + payloadSize); + + // If we had to truncate the string to fit in the payload, we want to overwrite the final character + // with null. + if (categoryNameSize > finalNameSize) + { + payload.category.name[finalNameSize - 1] = '\0'; + } + } + }; + + DD_CHECK_SIZE(QueryCategoriesDataResponsePayload, sizeof(LoggingHeader) + sizeof(NamedLoggingCategory)); + + DD_NETWORK_STRUCT(LogMessagePayload, 8) + { + LoggingHeader header; + LogMessage message; + + static void WritePayload( + const LogMessage& message, + Version sessionVersion, + size_t messageSize, + SizedPayloadContainer* pContainer) + { + DD_ASSERT(pContainer != nullptr); + const size_t maxStringSize = + (sessionVersion >= LOGGING_LARGE_MESSAGES_VERSION) ? sizeof(message.message) : kMaxStringLength; + const size_t finalMessageSize = Platform::Min(messageSize, maxStringSize); + const uint32 payloadSize = + static_cast(offsetof(LogMessagePayload, message.message) + finalMessageSize); + + pContainer->payloadSize = payloadSize; + + LogMessagePayload& payload = pContainer->GetPayload(); + payload.header = LoggingHeader(LoggingMessage::LogMessage); + + memcpy(&payload.message, + &message, + payloadSize); + + // If we had to truncate the string to fit in the payload, we want to overwrite the final character + // with null. + if (messageSize > finalMessageSize) + { + payload.message.message[finalMessageSize - 1] = '\0'; + } + } + }; + + DD_CHECK_SIZE(LogMessagePayload, sizeof(LoggingHeader) + sizeof(LogMessage)); + } +} diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/loggingServer.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/loggingServer.h new file mode 100644 index 000000000..515d9272d --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/loggingServer.h @@ -0,0 +1,126 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file loggingServer.h +* @brief Class declaration for LoggingServer. +*********************************************************************************************************************** +*/ + +#pragma once +#include "baseProtocolServer.h" +#include "loggingProtocol.h" +#include "util/vector.h" +#include "util/queue.h" +#include "ddPlatform.h" + +#ifdef DEVDRIVER_LOG_CATEGORY_MASK +#define LOGGING_CATEGORY_MASK static_cast(DEVDRIVER_LOG_CATEGORY_MASK) +#else +#if defined(NDEBUG) +#define LOGGING_CATEGORY_MASK DevDriver::LoggingProtocol::kAllLoggingCategories +#else +#define LOGGING_CATEGORY_MASK DevDriver::LoggingProtocol::kAllLoggingCategories +#endif +#endif + +namespace DevDriver +{ + namespace LoggingProtocol + { + enum class SessionState + { + ReceivePayload = 0, + ProcessPayload, + SendPayload, + SendCategoriesNumResponse, + SendCategoriesDataResponse, + FinishLogging + }; + + struct LoggingSession + { + SizedPayloadContainer scratchPayload; + SharedPointer pSession; + Queue messages; + uint32 itemIndex; + uint32 numItems; + LoggingFilter filter; + SessionState state; + bool loggingEnabled; + + explicit LoggingSession(const AllocCb& allocCb, const SharedPointer& pSession) + : scratchPayload() + , pSession(pSession) + , messages(allocCb) + , itemIndex(0) + , numItems(0) + , filter() + , state(SessionState::ReceivePayload) + , loggingEnabled(false) + { + memset(&scratchPayload, 0, sizeof(scratchPayload)); + // Default to all messages enabled. + + filter.priority = LogLevel::Error; + filter.category = kAllLoggingCategories; + } + + // Helper functions for working with SizedPayloadContainers and managing back-compat. + Result SendPayload(const SizedPayloadContainer* pPayload, uint32 timeoutInMs); + }; + + class LoggingServer : public BaseProtocolServer + { + public: + explicit LoggingServer(IMsgChannel* pMsgChannel); + ~LoggingServer(); + + bool AcceptSession(const SharedPointer& pSession) override; + void SessionEstablished(const SharedPointer& pSession) override; + void UpdateSession(const SharedPointer& pSession) override; + void SessionTerminated(const SharedPointer& pSession, Result terminationReason) override; + + Result AddCategoryTable(uint32 offset, uint32 count, const char **pCategoryTable); + + void Log(LogLevel priority, LoggingCategory category, const char* pFormat, va_list args); + void Log(LogLevel priority, LoggingCategory category, const char* pFormat, ...) + { + va_list args; + va_start(args, pFormat); + Log(priority, category, pFormat, args); + va_end(args); + } + + private: + void LockData(); + void UnlockData(); + + NamedLoggingCategory m_categories[kMaxCategoryCount]; + Vector m_activeSessions; + Platform::Mutex m_mutex; + uint32 m_numCategories; + }; + } +} diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/rgpClient.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/rgpClient.h new file mode 100644 index 000000000..30ead029b --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/rgpClient.h @@ -0,0 +1,132 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file rgpClient.h +* @brief Class declaration for RGPClient. +*********************************************************************************************************************** +*/ + +#pragma once + +#include "baseProtocolClient.h" + +#include "protocols/rgpProtocol.h" + +namespace DevDriver +{ + class IMsgChannel; + + namespace RGPProtocol + { + typedef void(*TraceDataChunkReceived)(const TraceDataChunk* pChunk, void* pUserdata); + + struct ChunkCallbackInfo + { + TraceDataChunkReceived chunkCallback; + void* pUserdata; + }; + + struct ClientTraceParametersInfo + { + uint32 gpuMemoryLimitInMb; + uint32 numPreparationFrames; + + union + { + struct + { + uint32 enableInstructionTokens : 1; + uint32 allowComputePresents : 1; + uint32 reserved : 30; + }; + uint32 u32All; + } flags; + + uint64 beginTag; + uint64 endTag; + + char beginMarker[kMarkerStringLength]; + char endMarker[kMarkerStringLength]; + }; + + struct BeginTraceInfo + { + ClientTraceParametersInfo parameters; // Parameters for the trace + ChunkCallbackInfo callbackInfo; // Callback used to return trace data + }; + + class RGPClient : public BaseProtocolClient + { + public: + explicit RGPClient(IMsgChannel* pMsgChannel); + ~RGPClient(); + + // Requests an RGP trace in the driver. Returns Success if the request was successfully delivered. + Result BeginTrace(const BeginTraceInfo& traceInfo); + + // Waits until a previously requested trace completes in the driver and returns the result of the trace. + // If the trace was successful, the number of chunks generated is returned in pNumChunks and the size in + // bytes of the trace data is returned in pTraceSizeInBytes. + Result EndTrace(uint32* pNumChunks, uint64* pTraceSizeInBytes); + + // Reads a chunk of trace data from a previous trace that completed successfully. Returns chunk data + // via the callback provided earlier in BeginTraceInfo. + Result ReadTraceDataChunk(); + + // Aborts a trace in progress. + Result AbortTrace(); + + // Queries the current profiling status of the driver. + Result QueryProfilingStatus(ProfilingStatus* pStatus); + + // Enables profiling support inside the driver. ExecuteTrace will only succeed if the connected driver + // has profiling enabled. + Result EnableProfiling(); + + private: + void ResetState() override; + + enum class TraceState : uint32 + { + Idle = 0, + TraceRequested, + TraceCompleted, + Error + }; + + struct ClientTraceContext + { + TraceState state; + BeginTraceInfo traceInfo; + uint32 numChunksReceived; + uint32 numChunks; + }; + + ClientTraceContext m_traceContext; + + DD_STATIC_CONST uint32 kRGPChunkTimeoutInMs = 3000; + }; + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/rgpProtocol.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/rgpProtocol.h new file mode 100644 index 000000000..7c13ab4e6 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/rgpProtocol.h @@ -0,0 +1,301 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file rgpProtcol.h +* @brief Common interface for RGP Protocol. +*********************************************************************************************************************** +*/ + +#pragma once + +#pragma pack(push) + +#include "gpuopen.h" + +#define RGP_PROTOCOL_MAJOR_VERSION 6 +#define RGP_PROTOCOL_MINOR_VERSION 0 + +#define RGP_INTERFACE_VERSION ((RGP_INTERFACE_MAJOR_VERSION << 16) | RGP_INTERFACE_MINOR_VERSION) + +#define RGP_PROTOCOL_MINIMUM_MAJOR_VERSION 2 + +/* +*********************************************************************************************************************** +*| Version | Change Description | +*| ------- | ---------------------------------------------------------------------------------------------------------| +*| 6.0 | Added support for trace trigger markers. | +*| 5.0 | Added support for allow compute presents trace parameter and removed unused clock mode parameter. | +*| 4.0 | Added support for reporting trace transfer progress. | +*| 3.0 | Updated TraceParameters struct to allow for specifying profiling clock mode. | +*| 2.0 | Add TraceParameters struct and ExecuteTraceRequestPayload so a client can specify trace options. | +*| 1.0 | Initial version | +*********************************************************************************************************************** +*/ + +#define RGP_TRIGGER_MARKERS_VERSION 6 +#define RGP_COMPUTE_PRESENTS_VERSION 5 +#define RGP_TRACE_PROGRESS_VERSION 4 +#define RGP_PROFILING_CLOCK_MODES_VERSION 3 +#define RGP_TRACE_PARAMETERS_VERSION 2 +#define RGP_INITIAL_VERSION 1 + +namespace DevDriver +{ + namespace RGPProtocol + { + /////////////////////// + // RGP Protocol + enum struct RGPMessage : MessageCode + { + Unknown = 0, + ExecuteTraceRequest, + TraceDataChunk, + TraceDataSentinel, + QueryProfilingStatusRequest, + QueryProfilingStatusResponse, + EnableProfilingRequest, + EnableProfilingResponse, + TraceDataHeader, + AbortTrace, + Count + }; + + // @note: We currently subtract sizeof(uint32) instead of sizeof(RGPMessage) to work around struct packing issues. + // The compiler pads out RGPMessage to 4 bytes when it's included in the payload struct. It also pads out + // the TraceDataChunk data field to 1000 bytes. This causes the total payload size to be 1004 bytes which is + // 4 bytes larger than the maximum size allowed. + DD_STATIC_CONST Size kMaxTraceDataChunkSize = (kMaxPayloadSizeInBytes - sizeof(uint32) - sizeof(uint32)); + + /////////////////////// + // RGP Constants + const uint32 kMarkerStringLength = 256; + + /////////////////////// + // RGP Types + DD_NETWORK_STRUCT(TraceDataChunk, 4) + { + uint32 dataSize; + uint8 data[kMaxTraceDataChunkSize]; + }; + + DD_CHECK_SIZE(TraceDataChunk, kMaxTraceDataChunkSize + sizeof(int32)); + + DD_NETWORK_STRUCT(TraceParameters, 4) + { + uint32 gpuMemoryLimitInMb; + uint32 numPreparationFrames; + union + { + struct + { + uint32 enableInstructionTokens : 1; + uint32 reserved : 31; + }; + uint32 u32All; + } flags; + }; + + DD_CHECK_SIZE(TraceParameters, 12); + + enum struct ProfilingClockMode : uint32 + { + Stable = 0, + Max, + Normal, + Count + }; + + DD_NETWORK_STRUCT(TraceParametersV2, 4) + { + uint32 gpuMemoryLimitInMb; + uint32 numPreparationFrames; + ProfilingClockMode clockMode; + union + { + struct + { + uint32 enableInstructionTokens : 1; + uint32 reserved : 31; + }; + uint32 u32All; + } flags; + }; + + DD_CHECK_SIZE(TraceParametersV2, 16); + + DD_NETWORK_STRUCT(TraceParametersV3, 4) + { + uint32 gpuMemoryLimitInMb; + uint32 numPreparationFrames; + union + { + struct + { + uint32 enableInstructionTokens : 1; + uint32 allowComputePresents : 1; + uint32 reserved : 30; + }; + uint32 u32All; + } flags; + }; + + DD_CHECK_SIZE(TraceParametersV3, 12); + + DD_NETWORK_STRUCT(TraceParametersV4, 4) + { + uint32 gpuMemoryLimitInMb; + uint32 numPreparationFrames; + union + { + struct + { + uint32 enableInstructionTokens : 1; + uint32 allowComputePresents : 1; + uint32 reserved : 30; + }; + uint32 u32All; + } flags; + + // Begin Tag + uint32 beginTagHigh; + uint32 beginTagLow; + + // End Tag + uint32 endTagHigh; + uint32 endTagLow; + + // Begin/End Marker Strings + char beginMarker[kMarkerStringLength]; + char endMarker[kMarkerStringLength]; + }; + + DD_CHECK_SIZE(TraceParametersV4, 540); + + enum struct ProfilingStatus : uint32 + { + NotAvailable = 0, + Available, + Enabled, + Count + }; + + /////////////////////// + // RGP Payloads + + DD_NETWORK_STRUCT(ExecuteTraceRequestPayload, 4) + { + TraceParameters parameters; + }; + + DD_CHECK_SIZE(ExecuteTraceRequestPayload, 12); + + DD_NETWORK_STRUCT(ExecuteTraceRequestPayloadV2, 4) + { + TraceParametersV2 parameters; + }; + + DD_CHECK_SIZE(ExecuteTraceRequestPayloadV2, 16); + + DD_NETWORK_STRUCT(ExecuteTraceRequestPayloadV3, 4) + { + TraceParametersV3 parameters; + }; + + DD_CHECK_SIZE(ExecuteTraceRequestPayloadV3, 12); + + DD_NETWORK_STRUCT(ExecuteTraceRequestPayloadV4, 4) + { + TraceParametersV4 parameters; + }; + + DD_CHECK_SIZE(ExecuteTraceRequestPayloadV4, 540); + + DD_NETWORK_STRUCT(ExecuteTraceResponsePayload, 4) + { + Result result; + }; + + DD_CHECK_SIZE(ExecuteTraceResponsePayload, 4); + + DD_NETWORK_STRUCT(TraceDataChunkPayload, 4) + { + TraceDataChunk chunk; + }; + + DD_CHECK_SIZE(TraceDataChunkPayload, kMaxTraceDataChunkSize + sizeof(int32)); + + DD_NETWORK_STRUCT(TraceDataSentinelPayload, 4) + { + Result result; + }; + + DD_CHECK_SIZE(TraceDataSentinelPayload, 4); + + DD_NETWORK_STRUCT(TraceDataHeaderPayload, 4) + { + Result result; + uint32 numChunks; + uint32 sizeInBytes; + }; + + DD_CHECK_SIZE(TraceDataHeaderPayload, 12); + + DD_NETWORK_STRUCT(QueryProfilingStatusResponsePayload, 4) + { + ProfilingStatus status; + }; + + DD_CHECK_SIZE(QueryProfilingStatusResponsePayload, 4); + + DD_NETWORK_STRUCT(EnableProfilingResponsePayload, 4) + { + Result result; + }; + + DD_CHECK_SIZE(EnableProfilingResponsePayload, 4); + + DD_NETWORK_STRUCT(RGPPayload, 4) + { + RGPMessage command; + // pad out to 4 bytes for alignment requirements + char padding[3]; + union + { + ExecuteTraceRequestPayload executeTraceRequest; + ExecuteTraceRequestPayloadV2 executeTraceRequestV2; + ExecuteTraceRequestPayloadV3 executeTraceRequestV3; + ExecuteTraceRequestPayloadV4 executeTraceRequestV4; + ExecuteTraceResponsePayload executeTraceResponse; + TraceDataChunkPayload traceDataChunk; + TraceDataSentinelPayload traceDataSentinel; + TraceDataHeaderPayload traceDataHeader; + QueryProfilingStatusResponsePayload queryProfilingStatusResponse; + EnableProfilingResponsePayload enableProfilingStatusResponse; + }; + }; + + DD_CHECK_SIZE(RGPPayload, kMaxPayloadSizeInBytes); + } +} diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/rgpServer.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/rgpServer.h new file mode 100644 index 000000000..7fe68d6b0 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/rgpServer.h @@ -0,0 +1,133 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file rgpServer.h +* @brief Class declaration for RGPServer. +*********************************************************************************************************************** +*/ + +#pragma once + +#include "baseProtocolServer.h" + +#include "rgpProtocol.h" + +namespace DevDriver +{ + namespace RGPProtocol + { + enum class TraceStatus : uint32 + { + Idle = 0, + Pending, + Running, + Finishing, + Aborting + }; + + struct ServerTraceParametersInfo + { + uint32 gpuMemoryLimitInMb; + uint32 numPreparationFrames; + + union + { + struct + { + uint32 enableInstructionTokens : 1; + uint32 allowComputePresents : 1; + uint32 reserved : 30; + }; + uint32 u32All; + } flags; + + uint64 beginTag; + uint64 endTag; + + char beginMarker[kMarkerStringLength]; + char endMarker[kMarkerStringLength]; + }; + + struct RGPSession; + + class RGPServer : public BaseProtocolServer + { + public: + explicit RGPServer(IMsgChannel* pMsgChannel); + ~RGPServer(); + + void Finalize() override; + + bool AcceptSession(const SharedPointer& pSession) override; + void SessionEstablished(const SharedPointer& pSession) override; + void UpdateSession(const SharedPointer& pSession) override; + void SessionTerminated(const SharedPointer& pSession, Result terminationReason) override; + + // Returns true if traces are currently enabled. + bool TracesEnabled(); + + // Allows remote clients to request traces. + Result EnableTraces(); + + // Disable support for traces. + Result DisableTraces(); + + // Returns true if a client has requested a trace and it has not been started yet. + bool IsTracePending(); + + // Returns true if a client has requested a trace and it is currently running. + bool IsTraceRunning(); + + // Starts a new trace. This will only succeed if a trace was previously pending. + Result BeginTrace(); + + // Ends a trace. This will only succeed if a trace was previously in progress. + Result EndTrace(); + + // Aborts a trace. This will only succeed if a trace was previously in progress. + Result AbortTrace(); + + // Writes data into the current trace. This can only be performed when there is a trace in progress. + Result WriteTraceData(const uint8* pTraceData, size_t traceDataSize); + + // Returns the current profiling status on the rgp server. + ProfilingStatus QueryProfilingStatus(); + + // Returns the current trace parameters on the rgp server. + ServerTraceParametersInfo QueryTraceParameters(); + + private: + void LockData(); + void UnlockData(); + void ClearCurrentSession(); + + Platform::Mutex m_mutex; + TraceStatus m_traceStatus; + RGPSession* m_pCurrentSessionData; + ProfilingStatus m_profilingStatus; + ServerTraceParametersInfo m_traceParameters; + }; + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/settingsClient.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/settingsClient.h new file mode 100644 index 000000000..7533805fa --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/settingsClient.h @@ -0,0 +1,62 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file settingsClient.h +* @brief Protocol Client for the Settings Protocol +*********************************************************************************************************************** +*/ + +#pragma once + +#define SETTINGS_CLIENT_MIN_MAJOR_VERSION 1 +#define SETTINGS_CLIENT_MAX_MAJOR_VERSION 2 + +#include "settingsProtocol.h" +#include "baseProtocolClient.h" + +namespace DevDriver +{ + namespace SettingsProtocol + { + class SettingsClient : public BaseProtocolClient + { + public: + explicit SettingsClient(IMsgChannel* pMsgChannel); + ~SettingsClient(); + + Result QueryNumCategories(uint32* pNumCategories); + Result QueryCategories(SettingCategory* pCategoriesBuffer, uint32 bufferSizeInCategories); + + Result QueryNumSettings(uint32* pNumSettings); + Result QuerySettings(Setting* pSettingsBuffer, uint32 bufferSizeInSettings); + + Result QuerySetting(const char* pName, Setting* pSetting); + + Result SetSetting(const char* pName, const SettingValue* pValue); + + private: + }; + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/settingsProtocol.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/settingsProtocol.h new file mode 100644 index 000000000..6496f1036 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/settingsProtocol.h @@ -0,0 +1,264 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file settingsProtocol.h +* @brief Protocol header for the Settings Protocol +*********************************************************************************************************************** +*/ + +#pragma once + +#include "gpuopen.h" + +#define SETTINGS_PROTOCOL_MAJOR_VERSION 2 +#define SETTINGS_PROTOCOL_MINOR_VERSION 0 + +#define SETTINGS_INTERFACE_VERSION ((GPUOPEN_INTERFACE_MAJOR_VERSION << 16) | GPUOPEN_INTERFACE_MINOR_VERSION) + +#define SETTINGS_PROTOCOL_MINIMUM_MAJOR_VERSION 1 + +#ifndef SETTINGS_CLIENT_MIN_MAJOR_VERSION +static_assert(false, "Client must define SETTINGS_CLIENT_MIN_MAJOR_VERSION."); +#else +static_assert((SETTINGS_CLIENT_MIN_MAJOR_VERSION >= SETTINGS_PROTOCOL_MINIMUM_MAJOR_VERSION) && +(SETTINGS_CLIENT_MIN_MAJOR_VERSION <= SETTINGS_PROTOCOL_MAJOR_VERSION), +"The specified SETTINGS_CLIENT_MIN_MAJOR_VERSION is not supported."); +#endif + +#ifndef SETTINGS_CLIENT_MAX_MAJOR_VERSION +static_assert(false, "Client must define SETTINGS_CLIENT_MAX_MAJOR_VERSION."); +#else +static_assert((SETTINGS_CLIENT_MAX_MAJOR_VERSION >= SETTINGS_PROTOCOL_MINIMUM_MAJOR_VERSION) && +(SETTINGS_CLIENT_MAX_MAJOR_VERSION <= SETTINGS_PROTOCOL_MAJOR_VERSION), +"The specified SETTINGS_CLIENT_MAX_MAJOR_VERSION is not supported."); +#endif + +/* +*********************************************************************************************************************** +*| Version | Change Description | +*| ------- | ---------------------------------------------------------------------------------------------------------| +*| 2.0 | Add hex setting type to protocol. | +*| 1.0 | Initial version. | +*********************************************************************************************************************** +*/ + +#define SETTINGS_HEX_VERSION 2 +#define SETTINGS_INITIAL_VERSION 1 + +#define SETTINGS_PROTOCOL_SUPPORTS(x) ((SETTINGS_CLIENT_MAX_MAJOR_VERSION >= x) && (x >= SETTINGS_CLIENT_MIN_MAJOR_VERSION)) + +namespace DevDriver +{ + + namespace SettingsProtocol + { + /////////////////////// + // Settings Constants + DD_STATIC_CONST uint32 kSmallStringSize = 64; + DD_STATIC_CONST uint32 kLargeStringSize = 256; + + /////////////////////// + // Settings Protocol + enum struct SettingsMessage : MessageCode + { + Unknown = 0, + QueryNumSettingsRequest, + QueryNumSettingsResponse, + QuerySettingsRequest, + QuerySettingsNumResponse, + QuerySettingsDataResponse, + QuerySettingRequest, + QuerySettingResponse, + SetSettingRequest, + SetSettingResponse, + QueryNumCategoriesRequest, + QueryNumCategoriesResponse, + QueryCategoriesRequest, + QueryCategoriesNumResponse, + QueryCategoriesDataResponse, + Count + }; + + /////////////////////// + // Setting Types + enum struct SettingType : uint32 + { + Unknown = 0, + Boolean, + Integer, + UnsignedInteger, + Float, + String, +#if SETTINGS_PROTOCOL_SUPPORTS(SETTINGS_HEX_VERSION) + Hex, +#endif + Count + }; + + /////////////////////// + // Setting Value Structure + DD_NETWORK_STRUCT(SettingValue, 4) + { + union + { + bool boolValue; + int32 integerValue; + uint32 unsignedIntegerValue; +#if SETTINGS_PROTOCOL_SUPPORTS(SETTINGS_HEX_VERSION) + uint32 hexValue; +#endif + float floatValue; + char stringValue[kSmallStringSize]; + }; + }; + + DD_CHECK_SIZE(SettingValue, 64); + + /////////////////////// + // Setting Structure + DD_NETWORK_STRUCT(Setting, 4) + { + char description[kLargeStringSize]; + char name[kSmallStringSize]; + SettingValue value; + SettingValue defaultValue; + SettingType type; + uint32 categoryIndex; + }; + + DD_CHECK_SIZE(Setting, 456); + + /////////////////////// + // Category Structure + DD_NETWORK_STRUCT(SettingCategory, 4) + { + char name[kSmallStringSize]; + int32 parentIndex; + }; + + DD_CHECK_SIZE(SettingCategory, 68); + + /////////////////////// + // Payloads + DD_NETWORK_STRUCT(QueryNumSettingsResponsePayload, 4) + { + uint32 numSettings; + }; + DD_CHECK_SIZE(QueryNumSettingsResponsePayload, 4); + + DD_NETWORK_STRUCT(QuerySettingsNumResponsePayload, 4) + { + uint32 numSettings; + }; + DD_CHECK_SIZE(QuerySettingsNumResponsePayload, 4); + + DD_NETWORK_STRUCT(QuerySettingsDataResponsePayload, 4) + { + Setting setting; + }; + + DD_CHECK_SIZE(QuerySettingsDataResponsePayload, 456); + + DD_NETWORK_STRUCT(QuerySettingRequestPayload, 4) + { + char name[kSmallStringSize]; + }; + DD_CHECK_SIZE(QuerySettingRequestPayload, 64); + + DD_NETWORK_STRUCT(QuerySettingResponsePayload, 4) + { + Setting setting; + // todo: replace this with something that is more verbose at a later date + // avoided for the time being as it would cause a breaking API change + uint8 success; + // pad out for alignment requirements + uint8 padding[3]; + }; + + DD_CHECK_SIZE(QuerySettingResponsePayload, 460); + + DD_NETWORK_STRUCT(SetSettingRequestPayload, 4) + { + char name[kSmallStringSize]; + SettingValue value; + }; + + DD_CHECK_SIZE(SetSettingRequestPayload, 128); + + DD_NETWORK_STRUCT(SetSettingResponsePayload, 4) + { + // todo: replace this with something that is more verbose at a later date + // avoided for the time being as it would cause a breaking API change + uint8 success; + // pad out to 4 bytes for alignment requirements + uint8 padding[3]; + }; + + DD_CHECK_SIZE(SetSettingResponsePayload, 4); + + DD_NETWORK_STRUCT(QueryNumCategoriesResponsePayload, 4) + { + uint32 numCategories; + }; + + DD_CHECK_SIZE(QueryNumCategoriesResponsePayload, 4); + + DD_NETWORK_STRUCT(QueryCategoriesNumResponsePayload, 4) + { + uint32 numCategories; + }; + + DD_CHECK_SIZE(QueryCategoriesNumResponsePayload, 4); + + DD_NETWORK_STRUCT(QueryCategoriesDataResponsePayload, 4) + { + SettingCategory category; + }; + + DD_CHECK_SIZE(QueryCategoriesDataResponsePayload, 68); + + DD_NETWORK_STRUCT(SettingsPayload, 4) + { + SettingsMessage command; + // pad out to 4 bytes for alignment requirements + char padding[3]; + union + { + QueryNumSettingsResponsePayload queryNumSettingsResponse; + QuerySettingsNumResponsePayload querySettingsNumResponse; + QuerySettingsDataResponsePayload querySettingsDataResponse; + QuerySettingRequestPayload querySettingRequest; + QuerySettingResponsePayload querySettingResponse; + SetSettingRequestPayload setSettingRequest; + SetSettingResponsePayload setSettingResponse; + QueryNumCategoriesResponsePayload queryNumCategoriesResponse; + QueryCategoriesNumResponsePayload queryCategoriesNumResponse; + QueryCategoriesDataResponsePayload queryCategoriesDataResponse; + }; + }; + + DD_CHECK_SIZE(SettingsPayload, 464); + } +} diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/settingsServer.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/settingsServer.h new file mode 100644 index 000000000..14d9232bf --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/settingsServer.h @@ -0,0 +1,81 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file settingsServer.h +* @brief Class declaration for SettingServer. +*********************************************************************************************************************** +*/ + +#pragma once + +#define SETTINGS_CLIENT_MIN_MAJOR_VERSION 1 +#define SETTINGS_CLIENT_MAX_MAJOR_VERSION 2 + +#include "settingsProtocol.h" +#include "baseProtocolServer.h" +#include "util/vector.h" + +namespace DevDriver +{ + namespace SettingsProtocol + { + class SettingsServer : public BaseProtocolServer + { + public: + explicit SettingsServer(IMsgChannel* pMsgChannel); + ~SettingsServer(); + + void Finalize() override; + + bool AcceptSession(const SharedPointer& pSession) override; + void SessionEstablished(const SharedPointer& pSession) override; + void UpdateSession(const SharedPointer& pSession) override; + void SessionTerminated(const SharedPointer& pSession, Result terminationReason) override; + + void AddCategory(const char* pName, const char* pParentName); + int32 QueryCategoryIndex(const char* pName) const; + + void AddSetting(const Setting* pSetting); + bool QuerySetting(const char* pName, Setting* pSetting); + bool QuerySettingByIndex(uint32 settingIndex, Setting* pSetting); + bool UpdateSetting(const char* pName, const SettingValue* pValue); + bool UpdateSettingByIndex(uint32 settingIndex, const SettingValue* pValue); + + uint32 GetNumSettings(); + uint32 GetNumCategories(); + + private: + void LockData(); + void UnlockData(); + + int32 FindCategory(const char* pCategoryName) const; + int32 FindSetting(const char* pSettingName) const; + + Vector m_settings; + Vector m_categories; + Platform::Mutex m_mutex; + }; + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/systemProtocols.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/systemProtocols.h new file mode 100644 index 000000000..5ee322fe5 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/systemProtocols.h @@ -0,0 +1,222 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file systemProtocols.h +* @brief Protocol header for all system protocols +*********************************************************************************************************************** +*/ + +#pragma once + +#include "gpuopen.h" + +namespace DevDriver +{ + namespace SystemProtocol + { + /////////////////////// + // GPU Open System Protocol + enum struct SystemMessage : MessageCode + { + Unknown = 0, + ClientConnected, + ClientDisconnected, + Ping, + Pong, + QueryClientInfo, + ClientInfo, + Halted, + Count, + }; + } + + namespace SessionProtocol + { + /////////////////////// + // GPU Open Session Protocol + enum struct SessionMessage : MessageCode + { + Unknown = 0, + Syn, + SynAck, + Fin, + Data, + Ack, + Rst, + Count + }; + + typedef uint8 SessionVersion; + // Session protocol 2 lets session servers return session version as part of the synack + DD_STATIC_CONST SessionVersion kSessionProtocolVersionSynAckVersion = 2; + // Session protocol 1 lets session clients specify a max range supported as part of the syn + DD_STATIC_CONST SessionVersion kSessionProtocolRangeVersion = 1; + // current version is 2 + DD_STATIC_CONST SessionVersion kSessionProtocolVersion = kSessionProtocolVersionSynAckVersion; + // not mentioned is session version 0. It only supported min version in SynAck, servers reporting it cannot + // cleanly terminate in response to a Fin packet. + + // tripwire - this intentionally will break if the message version changes. Since that implies a breaking change, we need to address + // to re-baseline this as version 0 and update the SynPayload struct at the same time + static_assert(kMessageVersion == 1011, "Session packets need to be cleaned up as part of the next protocol version"); + + DD_NETWORK_STRUCT(SynPayload, 4) + { + Version minVersion; + Protocol protocol; + // pad out to 4 bytes + SessionVersion sessionVersion; + + // New fields read if sessionVersion != 0 + Version maxVersion; + // pad out to 8 bytes + uint8 reserved[2]; + }; + + DD_CHECK_SIZE(SynPayload, 8); + + // + // SynPayloadV2 is here so that we can use it with the next breaking message bus change. + // + //DD_NETWORK_STRUCT(SynPayloadV2, 4) + //{ + // Protocol protocol; + // SessionVersion sessionVersion; + // Version minVersion; + // Version maxVersion; + // // pad out to 8 bytes + // uint8 reserved[2]; + //}; + + //DD_CHECK_SIZE(SynPayloadV2, 8); + + DD_NETWORK_STRUCT(SynAckPayload, 8) + { + Sequence sequence; + SessionId initialSessionId; + Version version; + SessionVersion sessionVersion; + uint8 reserved[1]; + }; + + DD_CHECK_SIZE(SynAckPayload, 16); + } + + namespace ClientManagementProtocol + { + + /////////////////////// + // GPU Open ClientManagement Protocol + enum struct ManagementMessage : MessageCode + { + Unknown = 0, + ConnectRequest, + ConnectResponse, + DisconnectNotification, + DisconnectResponse, + SetClientFlags, + SetClientFlagsResponse, + QueryStatus, + QueryStatusResponse, + KeepAlive, + Count + }; + + DD_STATIC_CONST MessageBuffer kOutOfBandMessage = + { + { // header + kBroadcastClientId, //srcClientId + kBroadcastClientId, //dstClientId + Protocol::ClientManagement, //protocolId + 0, //messageId + 0, //windowSize + 0, //payloadSize + 0, //sessionId + kMessageVersion //sequence + }, + {} // payload + }; + + inline bool IsOutOfBandMessage(const MessageBuffer &message) + { + // an out of band message is denoted by both the dstClientId and srcClientId + // being initialized to kBroadcastClientId. + static_assert(kBroadcastClientId == 0, "Error, kBroadcastClientId is non-zero. IsOutOfBandMessage needs to be fixed"); + return ((message.header.dstClientId | message.header.srcClientId) == kBroadcastClientId); + } + + inline bool IsValidOutOfBandMessage(const MessageBuffer &message) + { + // an out of band message is only valid if the sequence field is initialized with the correct version + // and the protocolId is equal to the receiving client's Protocol::ClientManagement value + return ((message.header.sequence == kMessageVersion) & + (message.header.protocolId == Protocol::ClientManagement)); + } + + DD_NETWORK_STRUCT(ConnectRequestPayload, 4) + { + StatusFlags initialClientFlags; + uint8 padding[2]; + Component componentType; + uint8 reserved[3]; + }; + + DD_CHECK_SIZE(ConnectRequestPayload, 8); + + DD_NETWORK_STRUCT(ConnectResponsePayload, 4) + { + Result result; + ClientId clientId; + // pad this out to 8 bytes for future expansion + uint8 padding[2]; + }; + + DD_CHECK_SIZE(ConnectResponsePayload, 8); + + DD_NETWORK_STRUCT(SetClientFlagsPayload, 4) + { + StatusFlags flags; + uint8 padding[2]; + }; + + DD_CHECK_SIZE(SetClientFlagsPayload, 4); + + DD_NETWORK_STRUCT(SetClientFlagsResponsePayload, 4) + { + Result result; + }; + + DD_CHECK_SIZE(SetClientFlagsResponsePayload, 4); + + DD_NETWORK_STRUCT(QueryStatusResponsePayload, 4) + { + Result result; + StatusFlags flags; + uint8 reserved[2]; + }; + + DD_CHECK_SIZE(QueryStatusResponsePayload, 8); + } +} diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/typemap.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/typemap.h new file mode 100644 index 000000000..beb8311bc --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/protocols/typemap.h @@ -0,0 +1,198 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file map.h +* @brief Type mappings between protocol enum and client/server types. +*********************************************************************************************************************** +*/ + +#pragma once + +namespace DevDriver +{ + class IProtocolServer; + class IProtocolClient; + + template + struct ProtocolServerMap + { + typedef IProtocolServer type; + }; + + template + struct ProtocolClientMap + { + typedef IProtocolClient type; + }; + + template + using ProtocolServerType = typename ProtocolServerMap::type; + + template + using ProtocolClientType = typename ProtocolClientMap::type; + + namespace LoggingProtocol + { + class LoggingServer; + class LoggingClient; + } + + template <> + struct ProtocolServerMap + { + typedef LoggingProtocol::LoggingServer type; + }; + + template <> + struct ProtocolClientMap + { + typedef LoggingProtocol::LoggingClient type; + }; + + namespace SettingsProtocol + { + class SettingsServer; + class SettingsClient; + } + + template <> + struct ProtocolServerMap + { + typedef SettingsProtocol::SettingsServer type; + }; + + template <> + struct ProtocolClientMap + { + typedef SettingsProtocol::SettingsClient type; + }; + + namespace DriverControlProtocol + { + class DriverControlServer; + class DriverControlClient; + } + + template <> + struct ProtocolServerMap + { + typedef DriverControlProtocol::DriverControlServer type; + }; + + template <> + struct ProtocolClientMap + { + typedef DriverControlProtocol::DriverControlClient type; + }; + + namespace RGPProtocol + { + class RGPServer; + class RGPClient; + } + + template <> + struct ProtocolServerMap + { + typedef RGPProtocol::RGPServer type; + }; + + template <> + struct ProtocolClientMap + { + typedef RGPProtocol::RGPClient type; + }; + + namespace ETWProtocol + { + class ETWServer; + class ETWClient; + } + + template <> + struct ProtocolServerMap + { + typedef ETWProtocol::ETWServer type; + }; + + template <> + struct ProtocolClientMap + { + typedef ETWProtocol::ETWClient type; + }; + + namespace GpuCrashDumpProtocol + { + class GpuCrashDumpClient; + class GpuCrashDumpServer; + } + + template <> + struct ProtocolServerMap + { + typedef GpuCrashDumpProtocol::GpuCrashDumpServer type; + }; + + template <> + struct ProtocolClientMap + { + typedef GpuCrashDumpProtocol::GpuCrashDumpClient type; + }; + namespace TransferProtocol + { + class TransferServer; + class TransferClient; + } + + template <> + struct ProtocolServerMap + { + typedef TransferProtocol::TransferServer type; + }; + + template <> + struct ProtocolClientMap + { + typedef TransferProtocol::TransferClient type; + }; + + namespace URIProtocol + { + class URIServer; + class URIClient; + } + + template <> + struct ProtocolServerMap + { + typedef URIProtocol::URIServer type; + }; + + template <> + struct ProtocolClientMap + { + typedef URIProtocol::URIClient type; + }; +} diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/util/hashBase.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/util/hashBase.h new file mode 100644 index 000000000..23027f187 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/util/hashBase.h @@ -0,0 +1,813 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2017-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + /** + *********************************************************************************************************************** + * @file hashBase.h + * @brief Templated class to support common hash table functions. + *********************************************************************************************************************** + */ + +#pragma once + +#include "gpuopen.h" +#include "ddPlatform.h" +#include "memory.h" +#include "hashFunc.h" +#include + +namespace DevDriver +{ + // For the i-th block, it will hold Pow(2,i) groups, the whole array could have 4G groups. + DD_STATIC_CONST int32 kNumHashBlocks = 32; // Maximum number of blocks the container can implement + + /** + *********************************************************************************************************************** + * @brief Templated base class for HashMap and HashSet, supporting the ability to store, find, and remove entries. + * + * The hash container has a fixed number of buckets. These buckets contain a growable number of entry groups. Each + * entry group contains a fixed number of entries and a pointer to the next entry group in the bucket. + * + * This class aims to be very efficient when looking up the key and storing small attached items is the primary concern. + * It's therefore not desired to have the key associated with a pointer to the attached data, because the attached data + * may be of similar or smaller size than the pointer anyway, it would also introduce much unnecessary memory + * management, and it would imply a minimum of two cache misses in the typical lookup case. + * + * The idea is that these enty groups can be exactly the size of a cache line, so an entry group can be scanned with + * only a single cache miss. This extends the load factor that the hash-map can manage before performance begins to + * degrade. For the very small items that we expect, this should be a significant advantage; we expect one cache miss + * pretty much always, so packing the items together would not be a significant gain, and the cost in memory usage is + * (relatively) small. + *********************************************************************************************************************** + */ + template< + typename Key, + typename Entry, + typename HashFunc, + typename EqualFunc, + size_t NumBuckets, + size_t MinimumBucketSize = DD_CACHE_LINE_BYTES * 2> + class HashBase + { + public: + /// Returns number of entries in the container. + size_t Size() const { return m_numEntries; } + + /// Empty the hash container without freeing the underlying allocations. + void Reset() + { + if (m_curBlock >= 0) + { + // Reset the bucket head pointers + memset(&m_buckets[0], 0, sizeof(m_buckets)); + + // We need to destroy all object instances inside the hash map, so we iterate over all blocks + for (int32 i = 0; i <= m_curBlock; ++i) + { + MemBlock& block = m_blocks[i]; + + DD_ASSERT(block.pMemory != nullptr); + + // The number of buckets depends on which block it is + for (int32 j = 0; j < Platform::Pow2(i); j++) + { + // For every bucket in the block we need to destroy all object instances + Bucket& currentBucket = block.pMemory[j]; + if (!Platform::IsPod::Value) + { + for (uint32 k = 0; k < currentBucket.footer.numEntries; k++) + { + currentBucket.entries[k].~Entry(); + } + } + + // We then overwrite the footer + currentBucket.footer = Footer(); + + // Ensure that the footer was correctly zero initialized + DD_ASSERT(currentBucket.footer.pNextBucket == nullptr); + DD_ASSERT(currentBucket.footer.numEntries == 0); + } + + block.curBucket = 0; + } + + // Reset the object count + m_numEntries = 0; + m_curBlock = -1; + } + } + + /// Empty the hash container and dispose of all underlying allocations. + void Clear() + { + if (m_curBlock >= 0) + { + // Reset the bucket head pointers + memset(&m_buckets[0], 0, sizeof(m_buckets)); + + // Deallocate all blocks that have been allocated + for (int32 i = 0; i <= m_curBlock; ++i) + { + MemBlock& block = m_blocks[i]; + if (block.pMemory != nullptr) + { + // If this was not a POD type we want to explicitly destroy the object + if (!Platform::IsPod::Value) + { + for (int32 j = 0; j < Platform::Pow2(i); j++) + { + Bucket& currentBucket = block.pMemory[j]; + for (uint32 k = 0; k < currentBucket.footer.numEntries; k++) + { + currentBucket.entries[k].~Entry(); + } + } + } + + DD_FREE(block.pMemory, m_allocCb); + block.pMemory = nullptr; + block.curBucket = 0; + } + } + + // Reset the object count + m_numEntries = 0; + m_curBlock = -1; + } + } + + /// Returns true if the specified key exists in the set. + /// + /// @param [in] key Key to search for. + /// + /// @returns True if the specified key exists in the set. + bool Contains(const Key& key) const + { + // Get the bucket base address. + const Bucket* pBucket = FindBucket(key); + const Entry* pMatchingEntry = nullptr; + + while ((pBucket != nullptr) && (pMatchingEntry == nullptr)) + { + const Bucket& currentBucket = *pBucket; + + // Search this entry group. + for (uint32 i = 0; i < currentBucket.footer.numEntries; i++) + { + const Entry& entry = currentBucket.entries[i]; + if (this->m_equalFunc(entry.key, key)) + { + // We've found the entry. + pMatchingEntry = &entry; + break; + } + } + + // Chain to the next entry group. + pBucket = pBucket->footer.pNextBucket; + } + + return (pMatchingEntry != nullptr); + } + + /// Removes an entry that matches the specified key. + /// + /// @param [in] key Key of the entry to erase. + /// + /// @returns True if the erase completed successfully, false if an entry for this key did not exist. + Result Erase(const Key& key) + { + // Get the bucket base address. + Bucket* pBucket = this->FindBucket(key); + Entry* pFoundEntry = nullptr; + + // Find the entry to delete + while (pBucket != nullptr && (pBucket->footer.numEntries > 0)) + { + Bucket& currentBucket = *pBucket; + + // Search each group + for (uint32 i = 0; i < currentBucket.footer.numEntries; i++) + { + Entry& entry = currentBucket.entries[i]; + if (this->m_equalFunc(entry.key, key) == true) + { + // We shouldn't find the same key twice. + DD_ASSERT(pFoundEntry == nullptr); + + pFoundEntry = &entry; + break; + } + } + + if (pFoundEntry != nullptr) + break; + + // Chain to the next entry group. + pBucket = currentBucket.footer.pNextBucket; + } + + // Copy the last entry's data into the entry that we are removing and invalidate the last entry as it now appears + // earlier in the list. This also handles the case where the entry to be removed is the last entry. + + if (pFoundEntry != nullptr) + { + Entry* pLastEntry = nullptr; + Bucket* pLastBucket = nullptr; + + while (pBucket != nullptr && (pBucket->footer.numEntries > 0)) + { + Bucket& currentBucket = *pBucket; + + // keep track of last entry of all groups in bucket + pLastEntry = &(currentBucket.entries[currentBucket.footer.numEntries - 1]); + pLastBucket = pBucket; + + // Chain to the next entry group. + pBucket = currentBucket.footer.pNextBucket; + } + + DD_ASSERT(pLastEntry != nullptr); + + // If this item isn't the last entry, then we move the last entry into it. + if (pFoundEntry != pLastEntry) + { + *pFoundEntry = Platform::Move(*pLastEntry); + } + + // If it wasn't a POD type we need to explicitly invoke the destructor on the last entry + if (!Platform::IsPod::Value) + { + pLastEntry->~Entry(); + } + + DD_ASSERT(this->m_numEntries > 0); + this->m_numEntries--; + pLastBucket->footer.numEntries--; + } + return (pFoundEntry != nullptr) ? Result::Success : Result::Error; + } + protected: + class BaseIterator; + + /// @internal Constructor + /// + /// @param [in] numBuckets Number of buckets to allocate for this hash container. The initial hash container + /// will take (buckets * DD_CACHE_LINE_BYTES) bytes. + /// @param [in] pAllocator The allocator that will allocate memory if required. + explicit HashBase(const AllocCb& allocCb) : + m_hashFunc(HashFunc(Platform::ConstLog2(kPaddedNumBuckets))), + m_equalFunc(EqualFunc()), + m_allocCb(allocCb), + m_numEntries(0), + m_blocks(), + m_curBlock(-1), + m_buckets() + { + } + + ///// @internal Constructor + ///// + ///// @param [in] numBuckets Number of buckets to allocate for this hash container. The initial hash container + ///// will take (buckets * DD_CACHE_LINE_BYTES) bytes. + ///// @param [in] pAllocator The allocator that will allocate memory if required. + HashBase(HashBase&& rhs) : + m_hashFunc(HashFunc(Platform::ConstLog2(kPaddedNumBuckets))), + m_equalFunc(EqualFunc()), + m_allocCb(rhs.m_allocCb), + m_numEntries(Platform::Exchange(rhs.m_numEntries, 0)), + m_curBlock(Platform::Exchange(rhs.m_curBlock, -1)) + { + // Copy pointers to allocations made by the other container + memcpy(m_blocks, rhs.m_blocks, sizeof(m_blocks)); + // Reset the object on the right hand side + memset(rhs.m_blocks, 0, sizeof(m_blocks)); + + // Copy the pointers from the right hand container + memcpy(m_buckets, rhs.m_buckets, sizeof(m_buckets)); + // Reset the object on the right hand side + memset(rhs.m_buckets, 0, sizeof(m_buckets)); + } + + virtual ~HashBase() + { + Clear(); + } + + // ============================================================================================================ + // Gets a pointer to the value that matches the key. Returns null if no entry is present matching the + // specified key. + Entry* FindEntry(const Key& key) const + { + // Get the bucket base address. + Bucket* pBucket = this->FindBucket(key); + Entry* pMatchingEntry = nullptr; + + while (pBucket != nullptr) + { + Bucket& currentBucket = *pBucket; + + // Search this entry group + for (uint32 i = 0; i < currentBucket.footer.numEntries; i++) + { + Entry& entry = currentBucket.entries[i]; + + if (this->m_equalFunc(entry.key, key)) + { + // We've found the entry. + pMatchingEntry = &entry; + break; + } + } + + if (pMatchingEntry != nullptr) + { + break; + } + + // Chain to the next entry group. + pBucket = currentBucket.footer.pNextBucket; + } + + return pMatchingEntry; + } + + // ============================================================================================================ + // Gets a BaseIterator to the value that matches the key. Returns invalid Iterator if the value is not found + BaseIterator FindIterator(const Key& key) const + { + // Get the bucket base address. + const uint32 bucket = m_hashFunc(&key) & (kPaddedNumBuckets - 1); + Bucket* pBucket = m_buckets[bucket]; + + while (pBucket != nullptr) + { + Bucket& currentBucket = *pBucket; + + // Search this entry group + for (uint32 i = 0; i < currentBucket.footer.numEntries; i++) + { + if (this->m_equalFunc(currentBucket.entries[i].key, key)) + { + // We've found the entry. + return BaseIterator(this, bucket, bucket, pBucket, i); + } + } + + // Chain to the next entry group. + pBucket = currentBucket.footer.pNextBucket; + } + + return BaseIterator(this, static_cast(kPaddedNumBuckets)); + } + + /// Finds a given entry; if no entry was found, allocate it. + /// + /// @param [in] key Key to search for. + /// @param [out] pExisted True if an entry for the specified key existed before this call was made. False + /// indicates that a new entry was allocated as a result of this call. + /// @returns @ref Readable/writeable value in the hash map corresponding to the specified key. + Entry* FindOrAllocate(const Key& key, + bool* pExisted = nullptr) // [out] True if a matching key was found. + { + // Get the bucket base address. + const uint32 bucket = m_hashFunc(&key) & (kPaddedNumBuckets - 1); + Bucket** ppBucket = &m_buckets[bucket]; + bool existed = false; + + Entry* pMatchingEntry = nullptr; + + while (pMatchingEntry == nullptr) + { + Bucket* pBucket = *ppBucket; + + if (pBucket == nullptr) + { + pBucket = AllocateBucket(); + DD_ASSERT(pBucket != nullptr); + + *ppBucket = pBucket; + } + + Bucket& currentBucket = *pBucket; + + // Search this entry group. + for (uint32 i = 0; i < currentBucket.footer.numEntries; i++) + { + Entry& entry = currentBucket.entries[i]; + if (this->m_equalFunc(entry.key, key)) + { + // We've found the entry. + pMatchingEntry = &entry; + existed = true; + break; + } + } + + if ((pMatchingEntry == nullptr) & (currentBucket.footer.numEntries < kEntriesInBucket)) + { + // We've reached the end of the bucket and the entry was not found. Allocate this entry for the key. + Entry& entry = currentBucket.entries[currentBucket.footer.numEntries]; + new(&entry.key) Key(key); + pMatchingEntry = &entry; + currentBucket.footer.numEntries++; + this->m_numEntries++; + } + + if (pMatchingEntry != nullptr) + { + break; + } + + ppBucket = ¤tBucket.footer.pNextBucket; + } + + if (pExisted != nullptr) + { + *pExisted = existed; + } + return pMatchingEntry; + } + + /// Returns the bucket index containing the first element or an invalid bucket index if no buckets have been + /// allocated yet. + uint32 GetFirstBucket() const + { + uint32 bucket = 0; + + if (m_numEntries != 0) + { + for (; bucket < kPaddedNumBuckets; ++bucket) + { + if ((m_buckets[bucket] != nullptr) && (m_buckets[bucket]->footer.numEntries > 0)) + { + break; + } + } + } + else + { + // If the backing memory does not exist we should return an invalid bucket. + // This can be done by setting the start bucket such that it is off the end of the bucket list. + bucket = kPaddedNumBuckets; + } + + return bucket; + } + + /// Swaps the contents of this object with those of the object specified as a parameter. + void Swap(HashBase& other) + { + // exchange the stateful information + m_allocCb = Platform::Exchange(other.m_allocCb, m_allocCb); + m_numEntries = Platform::Exchange(other.m_numEntries, m_numEntries); + m_curBlock = Platform::Exchange(other.m_curBlock, m_curBlock); + + // calculate how many blocks need to be swapped + const int32 numBlocks = Platform::Min(Platform::Max(m_curBlock, other.m_curBlock) + 1, kNumHashBlocks); + + // exchange block pointers + for (int32 i = 0; i < numBlocks; i++) + { + m_blocks[i] = Platform::Exchange(other.m_blocks[i], m_blocks[i]); + } + + // exchange bucket pointers + for (size_t i = 0; i < kPaddedNumBuckets; i++) + { + m_buckets[i] = Platform::Exchange(other.m_buckets[i], m_buckets[i]); + } + } + + /// Removes an entry associated with the provided iterator + /// + /// @param [in] iterator BaseIterator created by the current object + /// + /// @returns True if the erase completed successfully, false if the iterator was invalid. + bool RemoveIterator(BaseIterator& iterator) + { + Entry* pFoundEntry = nullptr; + if ((iterator.m_pCurrentBucket != nullptr) & (iterator.m_pContainer == this)) + { + // Get the bucket base address. + Bucket* pBucket = iterator.m_pCurrentBucket; + + DD_ASSERT(this->m_numEntries > 0); + + pFoundEntry = iterator.Get(); + + DD_ASSERT(pFoundEntry != nullptr); + + // We need to look for the last entry in the current chain. We will then either swap this entry with + // last entry and destroy the object + Entry* pLastEntry = nullptr; + Bucket* pLastBucket = nullptr; + + while (pBucket != nullptr && (pBucket->footer.numEntries > 0)) + { + Bucket& currentBucket = *pBucket; + + // keep track of last entry of all groups in bucket + pLastEntry = &(currentBucket.entries[currentBucket.footer.numEntries - 1]); + pLastBucket = pBucket; + + // Chain to the next entry group. + pBucket = currentBucket.footer.pNextBucket; + } + + DD_ASSERT(pLastEntry != nullptr); + DD_ASSERT(pLastBucket != nullptr); + + this->m_numEntries--; + pLastBucket->footer.numEntries--; + + if (pFoundEntry != pLastEntry) + { + *pFoundEntry = Platform::Move(*pLastEntry); + } + else + { + // This was the last entry in the current bucket, so we need to advance the iterator + iterator.Next(); + } + + // If the element we removed wasn't a POD type we need to explicitly invoke the destructor + if (!Platform::IsPod::Value) + { + pLastEntry->~Entry(); + } + + } + return (pFoundEntry != nullptr); + } + + DD_STATIC_CONST size_t kPaddedNumBuckets = Platform::ConstPow2Pad(NumBuckets); + private: + struct Bucket; + struct Footer + { + Bucket* pNextBucket; + uint32 numEntries; + }; + + /// The native bucket size is going to be, at minimum, the size of an entry + footer, + /// aligned to the cache line. + DD_STATIC_CONST size_t kAlignedBucketSize = + Platform::Pow2Align(sizeof(Entry) + sizeof(Footer), DD_CACHE_LINE_BYTES); + + /// We pick the larger of the native bucket size and the minimum bucket size to ensure + /// that we always have enough room for at least one object. + DD_STATIC_CONST size_t kBucketSize = Platform::Max(kAlignedBucketSize, MinimumBucketSize); + + /// Number of entries in a single group. + DD_STATIC_CONST uint32 kEntriesInBucket = ((kBucketSize - sizeof(Footer)) / sizeof(Entry)); + + /// There must be at least one entry in each group. + static_assert((kEntriesInBucket >= 1), "Hash container entry is too big."); + + struct Bucket + { + Entry entries[kEntriesInBucket]; + Footer footer; + }; + + static_assert(sizeof(Bucket) <= kBucketSize, "Hash container entry is too big."); + + struct MemBlock + { + Bucket* pMemory = nullptr; // Pointer to the memory allocated for this block. + int32 curBucket = 0; // Current group index to be allocated. + }; + + const HashFunc m_hashFunc; ///< @internal Hash functor object. + const EqualFunc m_equalFunc; ///< @internal Key compare function object. + AllocCb m_allocCb; ///< @internal Allocator for this hash allocation function. + + uint32 m_numEntries; ///< @internal Entries in the table. + + MemBlock m_blocks[kNumHashBlocks]; ///< @internal Memory blocks for memory allocations. + int32 m_curBlock; ///< @internal Current block index buckets can be allocated + ///< from. -1 indicates no memory has been allocated yet + + Bucket* m_buckets[kPaddedNumBuckets]; ///< @internal Base address as allocated + ///< (before alignment). + + /// @internal Finds the bucket that matches the specified key + /// + /// @param [in] key Key to find matching bucket for. + /// + /// @returns Pointer to the bucket corresponding to the specified key. + Bucket* FindBucket(const Key& key) const + { + const uint32 bucket = m_hashFunc(&key) & (kPaddedNumBuckets - 1); + return m_buckets[bucket]; + } + + /// Allocates a new block of memory. + /// + /// No size parameter, the size of allocation is fixed to the groupSize parameter specified in the constructor. + /// + /// @returns A pointer to the allocate memory, or null if the allocation failed. + Bucket* AllocateBucket() + { + Bucket* pMemory = nullptr; + + // Leave pBlock null if this is the first allocation made with this object. + MemBlock* pBlock = (m_curBlock >= 0) ? &m_blocks[m_curBlock] : nullptr; + + // If current block is used up (or we haven't allocated one yet), go to next. + if ((pBlock == nullptr) || (pBlock->curBucket >= Platform::Pow2(m_curBlock))) + { + // Only advance to the next block if the current one had memory allocated to it (which implies that it's + // full). + int32 nextBlock = m_curBlock; + + if ((pBlock == nullptr) || (pBlock->pMemory != nullptr)) + { + nextBlock++; + } + + DD_ASSERT(nextBlock < kNumHashBlocks); + + pBlock = &m_blocks[nextBlock]; + + DD_ASSERT(pBlock->curBucket == 0); + + // Allocate memory if needed (note that this may rarely fail) + if (pBlock->pMemory == nullptr) + { + const size_t numBuckets = static_cast(Platform::Pow2(nextBlock)); + const size_t allocSize = sizeof(Bucket) * numBuckets; + pBlock->pMemory = reinterpret_cast(DD_CALLOC(allocSize, alignof(Bucket), m_allocCb)); + } + + // If we successfully allocated memory (or the block already had some), make it current + if (pBlock->pMemory != nullptr) + { + m_curBlock = nextBlock; + } + } + + if (pBlock->pMemory != nullptr) + { + pMemory = &pBlock->pMemory[pBlock->curBucket++]; + } + + return pMemory; + } + }; + + /** + *********************************************************************************************************************** + * @brief BaseIterator for traversal of elements in a Hash container. + * + * Backward iterating is not supported since there is no "footer" or "header" for a hash container. + *********************************************************************************************************************** + */ + template< + typename Key, + typename Entry, + typename HashFunc, + typename EqualFunc, + size_t NumBuckets, + size_t MinimumBucketSize> + class HashBase::BaseIterator + { + protected: + /// Returns a pointer to current entry. Will return null if the iterator has been advanced off the end of the + /// container. + Entry* Get() const { return &m_pCurrentBucket->entries[m_indexInBucket]; } + + // In order for an iterator to be considered equal it has to have the same: + // 1) Container + // 2) Current bucket + // 3) Index inside the bucket + // Note: this is not publicly exposed to prevent HashMap and HashSet from ever being directly comparable + bool Equals(const BaseIterator& rhs) const + { + return ((m_pContainer == rhs.m_pContainer) & + (m_currentBucket == rhs.m_currentBucket) & + (m_indexInBucket == rhs.m_indexInBucket)); + } + + /// Advances the iterator to the next position (move forward). + void Next() + { + if (m_pCurrentBucket != nullptr) + { + Bucket* pNextBucket = m_pCurrentBucket->footer.pNextBucket; + + // We're in the middle of a group. + if ((m_indexInBucket < kEntriesInBucket) && + (m_indexInBucket + 1 < m_pCurrentBucket->footer.numEntries)) + { + m_indexInBucket++; + } + // We're in the last entry of a group. + // Considering that the next chained group could be an empty group already, it is better to check the + // next group's footer->numEntries before jump to the next group. If the numEntry of the next chained + // group is 0 (invalid), we need to jump to the next bucket directly to avoid returning invalid entry. + else if ((pNextBucket != nullptr) && + (m_indexInBucket == m_pCurrentBucket->footer.numEntries - 1) && + (pNextBucket->footer.numEntries > 0)) + { + m_pCurrentBucket = pNextBucket; + m_indexInBucket = 0; + } + // The current bucket is done, step to the next. + else + { + do + { + m_currentBucket = (m_currentBucket + 1) % kPaddedNumBuckets; + + pNextBucket = m_pContainer->m_buckets[m_currentBucket]; + + if (pNextBucket != nullptr && pNextBucket->footer.numEntries > 0) + { + m_indexInBucket = 0; + break; + } + } while (m_currentBucket != m_startBucket); + + if (m_currentBucket != m_startBucket) + { + m_pCurrentBucket = pNextBucket; + m_indexInBucket = 0; + } + else + { + m_currentBucket = kPaddedNumBuckets; + m_pCurrentBucket = nullptr; + m_indexInBucket = 0; + } + } + } + } + + // Constructor. BaseIterator objects should never be directly created by anything. + BaseIterator( + const HashBase* pContainer, ///< [retained] The hash container to iterate over + uint32 startBucket) ///< The beginning bucket + : + m_pContainer(pContainer), + m_startBucket(startBucket), + m_currentBucket(startBucket), + m_pCurrentBucket(nullptr), + m_indexInBucket(0) + { + if (startBucket < kPaddedNumBuckets) + { + m_pCurrentBucket = m_pContainer->m_buckets[m_startBucket]; + } + } + + // Constructor that allows returning an Iterator to a specific object. + // BaseIterator objects should never be directly created by anything. + constexpr BaseIterator( + const HashBase* pContainer, ///< [retained] The hash container to iterate over + uint32 startBucket, + uint32 currentBucket, + Bucket* pCurrentBucket, + uint32 bucketIndex) ///< The beginning bucket + : + m_pContainer(pContainer), + m_startBucket(startBucket), + m_currentBucket(currentBucket), + m_pCurrentBucket(pCurrentBucket), + m_indexInBucket(bucketIndex) + { + } + + const HashBase* m_pContainer; // Hash container that we're iterating over. + uint32 m_startBucket; // Bucket where we start iterating. + uint32 m_currentBucket; // Current bucket we're iterating. + Bucket* m_pCurrentBucket; // Current group we're iterating (belongs to the current bucket). + uint32 m_indexInBucket; // Index of current entry in the group. + + // Although this is a transgression of coding standards, it means that Container does not need to have a public + // interface specifically to implement this class. The added encapsulation this provides is worthwhile. + friend HashBase; + }; +} diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/util/hashFunc.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/util/hashFunc.h new file mode 100644 index 000000000..6d3276a25 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/util/hashFunc.h @@ -0,0 +1,359 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2017-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + /** + *********************************************************************************************************************** + * @file hashFunc.h + * @brief Hashing and comparison functors used by HashMap and HashSet + *********************************************************************************************************************** + */ + +#pragma once + +#include "gpuopen.h" +#include "ddPlatform.h" +#include "memory.h" +#include + +namespace DevDriver +{ + /// Default hash functor. + /// + /// Just directly returns bits 31-6 of the key's first dword. This is a decent hash if the key is a pointer. + template + struct DefaultHashFunc + { + /// Shifts the key to the right and use the resulting bits as a uint hash. + /// + /// @param [in] pKey Pointer to the key to be hashed. If the key is a pointer, which is the best use case for + /// this hash function, then this is really a pointer to a pointer. + /// @returns 32-bit uint hash value. + uint32 operator()(const Key* pKey) const; + + DefaultHashFunc(uint32 minNumBits) { + // Calculate how many bits of precision are left over after accounting for the number of buckets. + const uint32 remainingPrecision = (uint32)Platform::Max(((kLength * 8) - (size_t)minNumBits), (size_t)0); + // We are going to shift by either how much precision is remaining, or the default shift value of 6 bits. + DD_STATIC_CONST uint32 kDefaultShiftNum = 6; ///< Right shift bit number + m_shiftNum = Platform::Min(remainingPrecision, kDefaultShiftNum); + }; + + private: + uint32 m_shiftNum; + DD_STATIC_CONST size_t kLength = Platform::Min(sizeof(Key), sizeof(uint32)); ///< How many bytes we read. + }; + + /// Null hash functor. + /// + /// Simply returns up to the first 4 bytes of the key. This works well for small, consecutive values (e.g., uint8) + template + struct NullHashFunc + { + /// Returns up to the first 4 bytes of the key + /// + /// @param [in] pKey Pointer to the key to be hashed. If the key is a pointer, which is the best use case for + /// this hash function, then this is really a pointer to a pointer. + /// @returns 32-bit uint hash value. + uint32 operator()(const Key* pKey) const; + + NullHashFunc(uint32 minNumBits) + { + DD_UNUSED(minNumBits); + }; + + private: + DD_STATIC_CONST size_t kLength = Platform::Min(sizeof(Key), sizeof(uint32)); ///< How many bytes we read. + }; + + /// Jenkins hash functor. + /// + /// Compute hash value according to the Jenkins algorithm. A description of the algorithm is found here: + /// http://burtleburtle.net/bob/hash/doobs.html + /// By Bob Jenkins, 1996. bob_jenkins@compuserve.com. You may use this + /// code any way you wish, private, educational, or commercial. It's free. + /// See http:\\ourworld.compuserve.com\homepages\bob_jenkins\evahash.htm + /// Use for hash table lookup, or anything where one collision in 2^^32 is + /// acceptable. Do NOT use for cryptographic purposes. + /// + template + struct JenkinsHashFunc + { + /// Hashes the specified key value via the Jenkins hash algorithm. + /// + /// @param [in] pKey Pointer to the key to be hashed. + /// @param [in] keyLen Amount of data at pVoidKey to hash, in bytes. + /// + /// @returns 32-bit uint hash value. + uint32 operator()(const Key* pKey, uint32 len = sizeof(Key)) const; + + /// Initialize local state. Does nothing for Jenkins + JenkinsHashFunc(uint32 minNumBits) + { + DD_UNUSED(minNumBits); + }; + }; + + /// Jenkins hash functor for C-style strings. + /// + /// Compute hash value according to the Jenkins algorithm. A description of the algorithm is found here: + /// http://burtleburtle.net/bob/hash/doobs.html + /// By Bob Jenkins, 1996. bob_jenkins@compuserve.com. You may use this + /// code any way you wish, private, educational, or commercial. It's free. + /// See http:\\ourworld.compuserve.com\homepages\bob_jenkins\evahash.htm + /// Use for hash table lookup, or anything where one collision in 2^^32 is + /// acceptable. Do NOT use for cryptographic purposes. + /// + /// @note This hash function is for char* keys only, since the regular JenkinsHashFunc will attempt to do a hash on the + /// address of the pointer, as opposed to the actual string. + template + struct StringJenkinsHashFunc : JenkinsHashFunc + { + /// Hashes the specified C-style string key via the Jenkins hash algorithm. + /// + /// @param [in] ppKey Pointer to the key string (i.e., this is a char**) to be hashed. + /// @param [in] keyLen Amount of data at pVoidKey to hash, in bytes. Should always be sizeof(char*). + /// + /// @returns 32-bit uint hash value. + uint32 operator()(const char** ppKey) const; + + /// Initialize local state. Does nothing. + StringJenkinsHashFunc(uint32 minNumBits) + { + DD_UNUSED(minNumBits); + }; + }; + + /// Generic compare functor for types that have defined the comparison operator + /// + /// Used by @ref HashBase to prevent defining compare functions for each type. + template + struct DefaultEqualFunc + { + /// Returns true if key1 and key2 are equal according to the equality operator + bool operator()(const Key& key1, const Key& key2) const + { + return (key1 == key2); + } + }; + + /// Generic compare functor for types with arbitrary size. + /// + /// Used by @ref HashBase to prevent defining compare functions for each type. + template + struct BitwiseEqualFunc + { + /// Returns true if key1 and key2 are equal (have identical memory contents). + bool operator()(const Key& key1, const Key& key2) const + { + return (memcmp(&key1, &key2, sizeof(Key)) == 0); + } + }; + + /// String compare functor for use with C-style strings. memcmp doesn't work well for strings, so this uses strcmp. + template + struct StringEqualFunc + { + /// Returns true if the strings in key1 and key2 are equal. + bool operator()(const Key& key1, const Key& key2) const; + }; + + // ===================================================================================================================== + // Reads up to 4 bytes of the object passed as a value + template + inline uint32 ReadAsUint32(Key* pKey) + { + uint32 key = *reinterpret_cast(pKey); + + switch (Platform::Min(sizeof(Key), sizeof(uint32))) + { + case 1: + key &= 0x000000FF; + break; + case 2: + key &= 0x0000FFFF; + break; + case 3: + key &= 0x00FFFFFF; + break; + default: + break; + } + return key; + } + + // ===================================================================================================================== + // Default hash function implementation. Simply shift the key to the right and use the resulting bits as the hash. + template + uint32 DefaultHashFunc::operator()( + const Key* pKey + ) const + { + return (ReadAsUint32(pKey) >> m_shiftNum); + } + + // ===================================================================================================================== + // Null hash function implementation. Simply returns up to the first 4 bytes of the key. + template + uint32 NullHashFunc::operator()( + const Key* pKey + ) const + { + return ReadAsUint32(pKey); + } + + // ===================================================================================================================== + // Hashes the specified key value with the Jenkins hash algorithm. Implementation based on the algorithm description + // found here: http://burtleburtle.net/bob/hash/doobs.html. + // By Bob Jenkins, 1996. bob_jenkins@compuserve.com. You may use this + // code any way you wish, private, educational, or commercial. It's free. + // See http:\\ourworld.compuserve.com\homepages\bob_jenkins\evahash.htm + // Use for hash table lookup, or anything where one collision in 2^^32 is + // acceptable. Do NOT use for cryptographic purposes. + template + uint32 JenkinsHashFunc::operator()( + const Key* pKey, + uint32 len + ) const + { + // Mixing table. + DD_STATIC_CONST uint8 MixTable[256] = + { + 251, 175, 119, 215, 81, 14, 79, 191, 103, 49, 181, 143, 186, 157, 0, 232, + 31, 32, 55, 60, 152, 58, 17, 237, 174, 70, 160, 144, 220, 90, 57, 223, + 59, 3, 18, 140, 111, 166, 203, 196, 134, 243, 124, 95, 222, 179, 197, 65, + 180, 48, 36, 15, 107, 46, 233, 130, 165, 30, 123, 161, 209, 23, 97, 16, + 40, 91, 219, 61, 100, 10, 210, 109, 250, 127, 22, 138, 29, 108, 244, 67, + 207, 9, 178, 204, 74, 98, 126, 249, 167, 116, 34, 77, 193, 200, 121, 5, + 20, 113, 71, 35, 128, 13, 182, 94, 25, 226, 227, 199, 75, 27, 41, 245, + 230, 224, 43, 225, 177, 26, 155, 150, 212, 142, 218, 115, 241, 73, 88, 105, + 39, 114, 62, 255, 192, 201, 145, 214, 168, 158, 221, 148, 154, 122, 12, 84, + 82, 163, 44, 139, 228, 236, 205, 242, 217, 11, 187, 146, 159, 64, 86, 239, + 195, 42, 106, 198, 118, 112, 184, 172, 87, 2, 173, 117, 176, 229, 247, 253, + 137, 185, 99, 164, 102, 147, 45, 66, 231, 52, 141, 211, 194, 206, 246, 238, + 56, 110, 78, 248, 63, 240, 189, 93, 92, 51, 53, 183, 19, 171, 72, 50, + 33, 104, 101, 69, 8, 252, 83, 120, 76, 135, 85, 54, 202, 125, 188, 213, + 96, 235, 136, 208, 162, 129, 190, 132, 156, 38, 47, 1, 7, 254, 24, 4, + 216, 131, 89, 21, 28, 133, 37, 153, 149, 80, 170, 68, 6, 169, 234, 151 + }; + + const uint8* pByteKey = static_cast(pKey); + + uint32 a = 0x9e3779b9; // The golden ratio; an arbitrary value. + uint32 b = a; + uint32 c = MixTable[pByteKey[0]]; // Arbitrary value. + + // Handle most of the key. + while (len >= 12) + { + a = a + (pByteKey[0] + (static_cast(pByteKey[1]) << 8) + + (static_cast(pByteKey[2]) << 16) + + (static_cast(pByteKey[3]) << 24)); + b = b + (pByteKey[4] + (static_cast(pByteKey[5]) << 8) + + (static_cast(pByteKey[6]) << 16) + + (static_cast(pByteKey[7]) << 24)); + c = c + (pByteKey[8] + (static_cast(pByteKey[9]) << 8) + + (static_cast(pByteKey[10]) << 16) + + (static_cast(pByteKey[11]) << 24)); + + a = a - b; a = a - c; a = a ^ (c >> 13); + b = b - c; b = b - a; b = b ^ (a << 8); + c = c - a; c = c - b; c = c ^ (b >> 13); + a = a - b; a = a - c; a = a ^ (c >> 12); + b = b - c; b = b - a; b = b ^ (a << 16); + c = c - a; c = c - b; c = c ^ (b >> 5); + a = a - b; a = a - c; a = a ^ (c >> 3); + b = b - c; b = b - a; b = b ^ (a << 10); + c = c - a; c = c - b; c = c ^ (b >> 15); + + pByteKey = pByteKey + 12; + len = len - 12; + } + + // Handle last 11 bytes. + c = c + sizeof(Key); + switch (len) + { + case 11: c = c + (static_cast(pByteKey[10]) << 24); // fall through + case 10: c = c + (static_cast(pByteKey[9]) << 16); // fall through + case 9: c = c + (static_cast(pByteKey[8]) << 8); // fall through + // the first byte of c is reserved for the length + case 8: b = b + (static_cast(pByteKey[7]) << 24); // fall through + case 7: b = b + (static_cast(pByteKey[6]) << 16); // fall through + case 6: b = b + (static_cast(pByteKey[5]) << 8); // fall through + case 5: b = b + pByteKey[4]; // fall through + case 4: a = a + (static_cast(pByteKey[3]) << 24); // fall through + case 3: a = a + (static_cast(pByteKey[2]) << 16); // fall through + case 2: a = a + (static_cast(pByteKey[1]) << 8); // fall through + case 1: a = a + pByteKey[0]; // fall through + // case 0: nothing left to add + } + + a = a - b; a = a - c; a = a ^ (c >> 13); + b = b - c; b = b - a; b = b ^ (a << 8); + c = c - a; c = c - b; c = c ^ (b >> 13); + a = a - b; a = a - c; a = a ^ (c >> 12); + b = b - c; b = b - a; b = b ^ (a << 16); + c = c - a; c = c - b; c = c ^ (b >> 5); + a = a - b; a = a - c; a = a ^ (c >> 3); + b = b - c; b = b - a; b = b ^ (a << 10); + c = c - a; c = c - b; c = c ^ (b >> 15); + + return c; + } + + // ===================================================================================================================== + // Hashes the specified C-style string key with the Jenkins hash algorithm. + template + uint32 StringJenkinsHashFunc::operator()( + const char** ppKey + ) const + { + const char* pKey = *ppKey; + const uint32 keyLen = static_cast(strlen(pKey)); + + return JenkinsHashFunc::operator()(pKey, keyLen); + } + + // ===================================================================================================================== + // Returns true if the strings in key1 and key2 are the same. + template + bool StringEqualFunc::operator()( + const Key& key1, + const Key& key2 + ) const + { + bool ret = false; + + // Can't do strcmp on null. + if ((key1 != nullptr) & (key2 != nullptr)) + { + ret = (strcmp(key1, key2) == 0); + } + else if ((key1 == nullptr) & (key2 == nullptr)) + { + ret = true; + } + + return ret; + } +} diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/util/hashMap.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/util/hashMap.h new file mode 100644 index 000000000..e0622c1c8 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/util/hashMap.h @@ -0,0 +1,393 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2017-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + /** + *********************************************************************************************************************** + * @file hashMap.h + * @brief Templated class implementing key/value map semantics + *********************************************************************************************************************** + */ + +#pragma once + +#include "hashBase.h" + +namespace DevDriver +{ + + /// Encapsulates one key/value pair in a hash map. + template + struct HashMapEntry + { + Key key; ///< Hash map entry key. + Value value; ///< Hash map entry value. + }; + + /** + *********************************************************************************************************************** + * @brief Templated hash map container. + * + * This container is meant for storing elements of an arbitrary (but uniform) key/value type. Supported operations: + * + * - Searching + * - Insertion + * - Deletion + * - Iteration + * + * HashFunc is a functor for hashing keys. Built-in choices for HashFunc are: + * + * - DefaultHashFunc: Good choice when the key is a pointer. + * - JenkinsHashFunc: Good choice when the key is arbitrary binary data. + * - StringJenkinsHashFunc: Good choice when the key is a C-style string. + * + * EqualFunc is a functor for comparing keys. Built-in choices for EqualFunc are: + * + * - DefaultEqualFunc: Determines keys are equal using teh equality operator. + * - BitwiseEqualFunc: Determines keys are equal by bitwise comparison. + * - StringEqualFunc: Treats keys as a char* and compares them as C-style strings. + * + * @warning This class is not thread-safe for Insert, FindAllocate, Erase, or iteration! + * @warning Init() must be called before using this container. Begin() and Reset() can be safely called before + * initialization and Begin() will always return an iterator that points to null. + * + * For more details please refer to @ref HashBase. + *********************************************************************************************************************** + */ + template class HashFunc = DefaultHashFunc, + template class EqualFunc = DefaultEqualFunc> + class HashMap : public HashBase, HashFunc, EqualFunc, NumBuckets> + { + public: + // Forward declare Iterator class + class Iterator; + + /// Convenience typedef for a templated entry of this hash map. + using Entry = HashMapEntry; + + /// @internal Constructor + /// + /// @param [in] allocCb Allocator callback struct used to allocate memory + explicit constexpr HashMap(const AllocCb& allocCb) : + Base::HashBase(allocCb) + { + } + + /// @internal Move Constructor + /// + /// @param [in] other HashMap object to move data from + HashMap(HashMap&& other) : + Base::HashBase(Platform::Forward(other)) + { + } + + /// @internal Destructor + /// + ~HashMap() { + } + + /// @internal Unifying copy operator + /// + /// Copy elision assignment operator. The compiler will decide whether to initialize the object via the move + /// or copy constructor. This borders on "compiler magic" but is (alarmingly) valid since it relies on the fact + /// that the compiler is able to generate a temporary copy of the parameter, then swaps contents of the current + /// object with those from the temporary copy. The temporary copy is then destroyed, effectively destroying the + /// the existing instance. Where things get weird is that the compiler, if the parameter is bound to an rvalue, + /// is allowed to use it directly without making a temporary copy. This allows the compiler to simply treat the + /// assignment as a swap, as opposed to having to copy all resources. The compiler is also allowed to do other + /// optimizations based on context, so the actual behavior of this operator is somewhat squirrel. It does, + /// however, allow implementing both the copy and move assignment operators with a single operator, relying + /// on the compiler to pick a contextually appropriate behavior. + HashMap& operator=(HashMap rhs) + { + Base::Swap(rhs); + return *this; + } + + /// Swaps the contents of who HashMap objects + /// + /// @param [in] other HashMap object to swap contents with + void Swap(HashMap& other) + { + Base::Swap(other); + } + + /// Gets a pointer to the value that matches the specified key. + /// + /// @param [in] key Key to search for. + /// + /// @returns A pointer to the value that matches the specified key or null if an entry for the key does not + /// exist. + Value* FindValue(const Key& key) const + { + // Get the bucket base address. + Entry* pMatchingEntry = Base::FindEntry(key); + return (pMatchingEntry != nullptr) ? &(pMatchingEntry->value) : nullptr; + } + + /// Gets the pointer associated with the specified key. Only valid if Value is a pointer type. + /// + /// @param [in] key Key to search for. + /// + /// @returns A pointer that matches the specified key or null if an entry for the key does not exist. + template ::Value>::Type> + T FindPointer(const Key& key) const + { + // Get the bucket base address. + Entry* pMatchingEntry = Base::FindEntry(key); + return (pMatchingEntry != nullptr) ? pMatchingEntry->value : nullptr; + } + + /// Finds a given entry; if no entry was found, allocate it. + /// + /// @param [in] key Key to search for. + /// @param [out] pExisted True if an entry for the specified key existed before this call was made. False indicates + /// that a new entry was allocated as a result of this call. + /// @returns @ref Readable/writeable value in the hash map corresponding to the specified key, or null if + /// the value didn't exist and an allocation could not be created. + template::Value>::Type> + U* FindAllocate(const Key& key, + bool* pExisted) // [out] True if a matching key was found. + { + Entry* pEntry = Base::FindOrAllocate(key, pExisted); + return (pEntry != nullptr) ? &(pEntry->value) : nullptr; + } + + /// Inserts or updates a key/value pair, overwriting the previous value if it existed. + /// + /// @param [in] key Key of the new entry to insert. + /// @param [in] args Parameters to be passed to the constructor of Value. + /// + /// @returns @ref Success if the operation completed successfully, or @ref InsufficientMemory if the operation + /// failed because an internal memory allocation failure. + template + Result Insert(const Key& key, Args&&... args) + { + bool existed = true; + Entry* pEntry = Base::FindOrAllocate(key, &existed); + // Ensure that that it found or allocated memory, and update the value. + if (pEntry != nullptr) + { + if (existed) + { + pEntry->value.~Value(); + } + new(&pEntry->value) Value(Platform::Forward(args)...); + } + return (pEntry != nullptr) ? Result::Success : Result::InsufficientMemory; + } + + /// Inserts a key/value pair entry if the key doesn't already exist in the hash map. + /// + /// @warning No action will be taken if an entry matching this key already exists, even if the specified value + /// differs from the current value stored in the entry matching the specified key. + /// + /// @param [in] key Key of the new entry to insert. + /// @param [in] value Value of the new entry to insert. + /// + /// @returns @ref Success if the operation completed successfully, @ref Error if the operation failed + /// because the object already exists, or @ref InsufficientMemory if an internal memory allocation + /// failed. + template + Result Create(const Key& key, Args&&... args) + { + bool existed = true; + Entry* pEntry = Base::FindOrAllocate(key, &existed); + Result result = Result::InsufficientMemory; + + // Add the new value if it did not exist already. + if (pEntry != nullptr) + { + if (existed == false) + { + new(&pEntry->value) Value(Platform::Forward(args)...); + result = Result::Success; + } + else + { + result = Result::Error; + } + } + return result; + } + + /// Subscript operator + /// + /// @warning This operator will attempt to de-reference the pointer regardless of if it is valid or not. + /// Do not use this if you are concerned about handling memory allocation failures gracefully. + /// + /// @param [in] key Key of the new entry to insert. + /// + /// @returns Reference to the value field associated with the key. + Value& operator[](const Key& key) + { + Entry* pEntry = FindOrCreate(key); + DD_ASSERT(pEntry != nullptr); + return pEntry->value; + } + + /// Finds and entry and returns an iterator to it + /// + /// @param [in] key key to look up in the HashMap + /// + /// @returns Iterator to the element, or Iterator equal to End(). + /// Warning: this iterator is not guaranteed to be able to iterate across the entire HashMap. + Iterator Find(const Key& key) const + { + return Iterator(Base::FindIterator(key)); + } + + /// Removes an entry using the provided iterator + /// + /// @param [in] iterator Iterator for the entry to be removed. + /// + /// @returns Iterator to the next element in the set + Iterator Remove(const Iterator& iterator) + { + Iterator result = iterator; + const bool didRemove = Base::RemoveIterator(result); + DD_ASSERT(didRemove); + DD_UNUSED(didRemove); + return result; + } + + // Creates a new iterator representing the beginning of the HashMap + Iterator Begin() const + { + return Iterator(this, Base::GetFirstBucket()); + } + + // Creates a new iterator representing the end of the HashMap + constexpr Iterator End() const + { + return Iterator(this, static_cast(Base::kPaddedNumBuckets)); + } + + protected: + // Typedef for the specialized 'HashBase' object we're inheriting from so we can use properly qualified names when + // accessing members of HashBase. + using Base = HashBase, EqualFunc, NumBuckets>; + + /// Finds an existing element, or allocates and constructs one to take it's place + /// + /// @param [in] key Key that you want to retrieve or create. + /// + /// @returns A pointer to the value that matches the specified key or null if an entry for the key does not + /// exist. + template::Value>::Type> + Entry* FindOrCreate(const Key& key, Args&&... args) + { + bool existed = true; + Entry* pEntry = Base::FindOrAllocate(key, &existed); + // Ensure that that it found or allocated memory, and update the value. + if ((pEntry != nullptr) && !existed) + { + new(&pEntry->value) Value(Platform::Forward(args)...); + } + return pEntry; + } + }; + + // Class declaration for HashMap::Iterator + template class HashFunc, + template class EqualFunc> + class HashMap::Iterator : protected Base::BaseIterator + { + friend HashMap; + public: + // Use base comparison method to implement != + bool operator!=(const Iterator &rhs) const + { + return !Base::BaseIterator::Equals(rhs); + } + + // Use base increment method to implement prefix operator + Iterator& operator++() + { + Base::BaseIterator::Next(); + return *this; + } + + // Use base access method to implement indirection operator + Entry& operator*() const + { + DD_ASSERT(Base::BaseIterator::m_pContainer != nullptr); + return *Base::BaseIterator::Get(); + } + + // Use base access method to implement member of pointer operator + Entry* operator->() const + { + DD_ASSERT(Base::BaseIterator::m_pContainer != nullptr); + return Base::BaseIterator::Get(); + } + + private: + // Constructor is private to ensure it cannot be created by anything other than the HashMap itself + Iterator(const HashMap* pContainer, uint32 startBucket) : + Base::BaseIterator(pContainer, startBucket) + { + } + + // Creates an Iterator object from a BaseIterator object. + // Constructor is private to ensure it cannot be created by anything other than the HashMap itself + Iterator(typename Base::BaseIterator&& iterator) : + Base::BaseIterator(iterator) + { + } + }; + + // + // functions necessary for C++ ranged based for loop support + // + + // Implement begin() function for range-based for loops + template class HashFunc, + template class EqualFunc> + inline typename HashMap::Iterator + begin(HashMap &rhs) + { + return rhs.Begin(); + } + + // Implement end() function for range-based for loops + template class HashFunc, + template class EqualFunc> + inline constexpr typename HashMap::Iterator + end(const HashMap &rhs) + { + return rhs.End(); + } +} diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/util/hashSet.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/util/hashSet.h new file mode 100644 index 000000000..910bfb05c --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/util/hashSet.h @@ -0,0 +1,271 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2017-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + /** + ********************************************************************************************************************* + * @file hashSet.h + * @brief Templated class implementing set semantics + ********************************************************************************************************************* + */ + +#pragma once + +#include "hashBase.h" + +namespace DevDriver +{ + + /// Encapsulates one entry of a hash set. + template + struct HashSetEntry + { + Key key; ///< Hash set entry key. + }; + + /** + ****************************************************************************************************************** + * @brief Templated hash set container. + * + * This is meant for storing elements of an arbitrary (but uniform) key type. Supported operations: + * + * - Searching + * - Insertion + * - Deletion + * - Iteration + * + * HashFunc is a functor for hashing keys. Built-in choices for HashFunc are: + * + * - DefaultHashFunc: Good choice when the key is a pointer. + * - JenkinsHashFunc: Good choice when the key is arbitrary binary data. + * - StringJenkinsHashFunc: Good choice when the key is a C-style string. + * + * EqualFunc is a functor for comparing keys. Built-in choices for EqualFunc are: + * + * - DefaultEqualFunc: Determines keys are equal using teh equality operator. + * - BitwiseEqualFunc: Determines keys are equal by bitwise comparison. + * - StringEqualFunc: Treats keys as a char* and compares them as C-style strings. + * + * @warning This class is not thread-safe for Insert, Erase, or iteration! + * @warning Init() must be called before using this container. Begin() and Reset() can be safely called before + * initialization and Begin() will always return an iterator that points to null. + * + * For more details please refer to @ref HashBase. + *********************************************************************************************************************** + */ + template class HashFunc = DefaultHashFunc, + template class EqualFunc = DefaultEqualFunc> + class HashSet : public HashBase, + HashFunc, + EqualFunc, + NumBuckets> + { + public: + // Forward declare Iterator class + class Iterator; + + /// Convenience typedef for a templated entry of this hash set. + typedef HashSetEntry Entry; + + /// @internal Constructor + /// + /// @param [in] allocCb Allocator callback struct used to allocate memory + explicit constexpr HashSet(const AllocCb& allocCb) : + Base::HashBase(allocCb) + { + } + + /// @internal Move Constructor + /// + /// @param [in] other HashSet object to move data from + HashSet(HashSet&& other) : + Base::HashBase(Platform::Forward(other)) + { + } + + /// @internal Destructor + /// + ~HashSet() + { + } + + /// @internal Unifying copy operator + /// + /// Copy elision assignment operator. The compiler will decide whether to initialize the object via the move + /// or copy constructor. This borders on "compiler magic" but is (alarmingly) valid since it relies on the fact + /// that the compiler is able to generate a temporary copy of the parameter, then swaps contents of the current + /// object with those from the temporary copy. The temporary copy is then destroyed, effectively destroying the + /// the existing instance. Where things get weird is that the compiler, if the parameter is bound to an rvalue, + /// is allowed to use it directly without making a temporary copy. This allows the compiler to simply treat the + /// assignment as a swap, as opposed to having to copy all resources. The compiler is also allowed to do other + /// optimizations based on context, so the actual behavior of this operator is somewhat squirrel. It does, + /// however, allow implementing both the copy and move assignment operators with a single operator, relying + /// on the compiler to pick a contextually appropriate behavior. + HashSet& operator=(HashSet rhs) + { + Base::Swap(rhs); + return *this; + } + + /// Swaps the contents of who HashSet objects + /// + /// @param [in] other HashSet to swap contents with + void Swap(HashSet& other) + { + Base::Swap(other); + } + + /// Inserts an entry. + /// + /// No action will be taken if an entry matching this key already exists in the set. + /// + /// @param [in] key New entry to insert. + /// + /// @returns @ref Success if the operation completed successfully, or @ref InsufficientMemory if the operation + /// failed because an internal memory allocation failed. + Result Insert(const Key& key) + { + const Entry* pEntry = Base::FindOrAllocate(key); + return (pEntry != nullptr) ? Result::Success : Result::InsufficientMemory; + } + + /// Finds and entry and returns an iterator to it + /// + /// @param [in] key key to look up in the HashSet + /// + /// @returns Iterator to the element, or Iterator equal to End(). + /// Warning: this iterator is not guaranteed to be able to iterate across the entire HashMap. + Iterator Find(const Key& key) const + { + return Iterator(Base::FindIterator(key)); + } + + /// Removes an entry using the provided iterator + /// + /// @param [in] iterator Iterator for the entry to be removed. + /// + /// @returns Iterator to the next element in the set + Iterator Remove(const Iterator& iterator) + { + Iterator result = iterator; + const bool didRemove = Base::RemoveIterator(result); + DD_ASSERT(didRemove); + DD_UNUSED(didRemove); + return result; + } + + // Creates a new iterator representing the beginning of the HashMap + Iterator Begin() const + { + return Iterator(this, Base::GetFirstBucket()); + } + + // Creates a new iterator representing the end of the HashMap + constexpr Iterator End() const + { + return Iterator(this, static_cast(Base::kPaddedNumBuckets)); + } + private: + // Typedef for the specialized 'HashBase' object we're inheriting from so we can use properly qualified names + // when accessing members of HashBase. + typedef HashBase, HashFunc, EqualFunc, NumBuckets> Base; + }; + + template class HashFunc, + template class EqualFunc> + class HashSet::Iterator : protected Base::BaseIterator + { + friend HashSet; + public: + // Use base comparison method to implement != + bool operator!=(const Iterator &rhs) const + { + return !Base::BaseIterator::Equals(rhs); + } + + // Use base increment method to implement prefix operator + Iterator& operator++() + { + Base::BaseIterator::Next(); + return *this; + } + + // Use base access method to implement indirection operator + Key& operator*() const + { + DD_ASSERT(Base::BaseIterator::m_pContainer != nullptr); + return Base::BaseIterator::Get()->key; + } + + // Use base access method to implement member of pointer operator + Key* operator->() const + { + DD_ASSERT(Base::BaseIterator::m_pContainer != nullptr); + return &Base::BaseIterator::Get()->key; + } + + private: + // Constructor is private to ensure it cannot be created by anything other than the HashSet itself + Iterator(const HashSet* pContainer, uint32 startBucket) : + Base::BaseIterator(pContainer, startBucket) + { + } + + // Creates an Iterator object from a BaseIterator object. + // Constructor is private to ensure it cannot be created by anything other than the HashMap itself + Iterator(typename Base::BaseIterator&& iterator) : + Base::BaseIterator(iterator) + { + } + }; + + // + // functions necessary for C++ ranged based for loop support + // + + // Implement begin() function for range-based for loops + template class HashFunc, + template class EqualFunc> + inline typename HashSet::Iterator + begin(HashSet &rhs) + { + return rhs.Begin(); + } + + // Implement end() function for range-based for loops + template class HashFunc, + template class EqualFunc> + inline constexpr typename HashSet::Iterator + end(const HashSet &rhs) + { + return rhs.End(); + } +} diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/util/memory.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/util/memory.h new file mode 100644 index 000000000..fb3858e11 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/util/memory.h @@ -0,0 +1,105 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file memory.h +* @brief GPUOpen common memory management definitions +*********************************************************************************************************************** +*/ + +#pragma once + +#include "template.h" +#include + +#define DD_CACHE_LINE_BYTES 64 +#define DD_DEFAULT_ALIGNMENT alignof(void*) + +#define DD_MALLOC(size, alignment, allocCb) allocCb.pfnAlloc(allocCb.pUserdata, size, Platform::Max(DD_DEFAULT_ALIGNMENT, alignment), false) +#define DD_CALLOC(size, alignment, allocCb) allocCb.pfnAlloc(allocCb.pUserdata, size, Platform::Max(DD_DEFAULT_ALIGNMENT, alignment), true) +#define DD_FREE(memory, allocCb) allocCb.pfnFree(allocCb.pUserdata, memory) + +#define DD_NEW(className, allocCb) new(DD_MALLOC(sizeof(className), alignof(className), allocCb)) className +#define DD_DELETE(memory, allocCb) DevDriver::Platform::Destructor(memory); DD_FREE(memory, allocCb) + +#define DD_NEW_ARRAY(className, numElements, allocCb) DevDriver::Platform::NewArray(numElements, allocCb) +#define DD_DELETE_ARRAY(memory, allocCb) DevDriver::Platform::DeleteArray(memory, allocCb) + +namespace DevDriver +{ + namespace Platform + { + + template + inline void static Destructor(T* p) + { + if (p != nullptr) + { + p->~T(); + } + } + + template + static T* NewArray(size_t numElements, const AllocCb& allocCb) + { + size_t allocSize = (sizeof(T) * numElements) + DD_CACHE_LINE_BYTES; + size_t allocAlign = DD_CACHE_LINE_BYTES; + + T* pMem = reinterpret_cast(DD_MALLOC(allocSize, allocAlign, allocCb)); + if (pMem != nullptr) + { + pMem = reinterpret_cast(reinterpret_cast(pMem) + DD_CACHE_LINE_BYTES); + size_t* pNumElements = reinterpret_cast(reinterpret_cast(pMem) - sizeof(size_t)); + *pNumElements = numElements; + T* pCurrentElement = pMem; + for (size_t elementIndex = 0; elementIndex < numElements; ++elementIndex) + { + new(pCurrentElement) T; + ++pCurrentElement; + } + } + + return pMem; + } + + template + static void DeleteArray(T* pElements, const AllocCb& allocCb) + { + if (pElements != nullptr) + { + size_t numElements = *reinterpret_cast(reinterpret_cast(pElements) - sizeof(size_t)); + T* pCurrentElement = pElements; + for (size_t elementIndex = 0; elementIndex < numElements; ++elementIndex) + { + pCurrentElement->~T(); + ++pCurrentElement; + } + + pElements = reinterpret_cast(reinterpret_cast(pElements) - DD_CACHE_LINE_BYTES); + } + + DD_FREE(pElements, allocCb); + } + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/util/queue.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/util/queue.h new file mode 100644 index 000000000..185484283 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/util/queue.h @@ -0,0 +1,679 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file queue.h +* @brief Templated double ended queue class for gpuopen +*********************************************************************************************************************** +*/ + +#pragma once + +#include "ddPlatform.h" +#include "template.h" +#include + +namespace DevDriver +{ + template + class Queue + { + public: + class Iterator; + + // Constructor - initialize with no storage + explicit constexpr Queue(const AllocCb& allocCb) + : m_pBlockIndexCache(nullptr) + , m_numBlocks(0) + , m_offset(0) + , m_size(0) + , m_allocCb(allocCb) + { + } + + // Move constructor - exchange all key data with rhs + Queue(Queue&& rhs) + : m_pBlockIndexCache(Platform::Exchange(rhs.m_pBlockIndexCache, nullptr)) + , m_numBlocks(Platform::Exchange(rhs.m_numBlocks, 0)) + , m_offset(Platform::Exchange(rhs.m_offset, 0)) + , m_size(Platform::Exchange(rhs.m_size, 0)) + , m_allocCb(rhs.m_allocCb) + { + } + + // Destructor - destroy everything than quite + ~Queue() + { + Clear(); + } + + // Copy elision assignment operator. The compiler will decide whether to initialize the object via the move + // or copy constructor. This borders on "compiler magic" but is (alarmingly) valid since it relies on the fact + // that the compiler is able to generate a temporary copy of the parameter, then swaps contents of the current + // object with those from the temporary copy. The temporary copy is then destroyed, effectively destroying the + // the existing instance. Where things get weird is that the compiler, if the parameter is bound to an rvalue, + // is allowed to use it directly without making a temporary copy. This allows the compiler to simply treat the + // assignment as a swap, as opposed to having to copy all resources. The compiler is also allowed to do other + // optimizations based on context, so the actual behavior of this operator is somewhat squirrel. It does, + // however, allow implementing both the copy and move assignment operators with a single operator, relying + // on the compiler to pick a contextually appropriate behavior. + Queue& operator=(Queue rhs) + { + Swap(rhs); + return *this; + } + + // + // subscript operators + // + T& operator[] (size_t index) + { + return _PeekIndex(index); + } + + const T& operator[] (size_t index) const + { + return _PeekIndex(index); + } + + // return the current size + size_t Size() const { + return m_size; + } + + // return the current capacity + size_t Capacity() const { + return kPaddedBlockSize * m_numBlocks; + } + + // returns true if empty + bool IsEmpty() const { + return (m_size == 0); + } + + // + // Insertion methods + // + + // Inserts the provided element at the front of the queue. + // Uses a variadic template parameter to allow construction of an object straight from parameters. + template + bool PushFront(Args&&... args) + { + T* pData = _AllocateFront(); + if (pData != nullptr) + { + new(pData) T(Platform::Forward(args)...); + } + return (pData != nullptr); + } + + // Inserts the provided element at the end of the queue. + // Uses a variadic template parameter to allow construction of an object straight from parameters. + template + bool PushBack(Args&&... args) + { + T* pData = _AllocateBack(); + if (pData != nullptr) + { + new(pData) T(Platform::Forward(args)...); + } + return (pData != nullptr); + } + + // Allocates memory for a new element at the front of the queue and returns a pointer. + // This method is intended to be the fastest way possible to allocate memory, under the assumption that + // the user will do either a memcpy or in place construction on it. Given that there is no way to ensure + // that the user actually constructs an object in place we limit this method to POD types only. + template::Value>::Type> + U* AllocateFront() + { + return _AllocateFront(); + } + + // Allocates memory for a new element at the back of the queue and returns a pointer. + // This method is intended to be the fastest way possible to allocate memory, under the assumption that + // the user will do either a memcpy or in place construction on it. Given that there is no way to ensure + // that the user actually constructs an object in place we limit this method to POD types only. + template::Value>::Type> + U* AllocateBack() + { + return _AllocateBack(); + } + + // + // Removal methods + // + + // Pop element from the front of the stack + bool PopFront() + { + bool result = !IsEmpty(); + if (result) + { + // If the object is not a POD, destroy the instance before we deallocate it. + if (!Platform::IsPod::Value) + { + _Front().~T(); + } + // Update state so that it is not part of the queue anymore. + _PopFront(); + } + return result; + } + + bool PopFront(T& output) + { + bool result = !IsEmpty(); + if (result) + { + // Move object out of the queue into object provided. + output = Platform::Move(_Front()); + // Update state so that it is not part of the queue anymore. + // If the object is not a POD, destroy the instance before we deallocate it. + if (!Platform::IsPod::Value) + { + _Front().~T(); + } + _PopFront(); + } + return result; + } + + // Pop element from the back + bool PopBack() + { + bool result = !IsEmpty(); + if (result) + { + // If the object is not a POD, destroy the instance before we deallocate it. + if (!Platform::IsPod::Value) + { + _Back().~T(); + } + // Update state so that it is not part of the queue anymore. + _PopBack(); + } + return result; + } + + bool PopBack(T& output) + { + bool result = !IsEmpty(); + if (result) + { + // Move object out of the queue into object provided. + output = Platform::Move(_Back()); + + // If the object is not a POD, destroy the instance before we deallocate it. + if (!Platform::IsPod::Value) + { + _Back().~T(); + } + + // Update state so that it is not part of the queue anymore. + _PopBack(); + } + return result; + } + + // + // Deprecated functions + // + bool PopFront(T* output) + { + if (output != nullptr) + return PopFront(*output); + else + return PopFront(); + } + + bool PopBack(T* output) + { + if (output != nullptr) + return PopBack(*output); + else + return PopBack(); + } + + // + // Maintenance methods + // + + // Peek functions + T* PeekBack() const + { + return (!IsEmpty())? &_Back() : nullptr; + } + + T* PeekFront() const + { + return (!IsEmpty()) ? &_Front() : nullptr; + } + + // Free all memory + void Clear() + { + if (m_pBlockIndexCache != nullptr) + { + Reset(); + + for (size_t i = 0; i < m_numBlocks; i++) + { + const QueueBlockPtr& pBlock = m_pBlockIndexCache[i]; + if (pBlock != nullptr) + { + DD_PRINT(LogLevel::Never, "[Queue::Clear] Freeing block at 0x%X", pBlock); + DD_FREE(pBlock, m_allocCb); + } + } + + DD_FREE(m_pBlockIndexCache, m_allocCb); + m_pBlockIndexCache = nullptr; + } + + m_numBlocks = 0; + } + + // Clears all objects stored, but doesn't free memory. + void Reset() + { + + while (!IsEmpty()) + { + // If the object is not a POD, destroy the instance before we deallocate it. + if (!Platform::IsPod::Value) + { + _Front().~T(); + } + // Update state so that it is not part of the queue anymore. + _PopFront(); + } + } + + // Swap two queues + void Swap(Queue& otherQueue) + { + m_pBlockIndexCache = Platform::Exchange(otherQueue.m_pBlockIndexCache, m_pBlockIndexCache); + m_numBlocks = Platform::Exchange(otherQueue.m_numBlocks, m_numBlocks); + m_offset = Platform::Exchange(otherQueue.m_offset, m_offset); + m_size = Platform::Exchange(otherQueue.m_size, m_size); + m_allocCb = Platform::Exchange(otherQueue.m_allocCb, m_allocCb); + } + + // Iterator creation function + Iterator Begin() const + { + return CreateIterator(0); + } + + // Iterator creation function + constexpr Iterator End() const + { + return Iterator(nullptr, 0); + } + + // Iterator creation function + Iterator CreateIterator(size_t index) const + { + if (index < m_size) + return Iterator(this, index); + return End(); + } + + // Finds the first index for the provided object + Iterator Find(const T& object) const + { + auto it = Begin(); + for (; it != End(); ++it) + { + if (*it == object) + { + break; + } + } + return it; + } + private: + DD_STATIC_CONST size_t kPaddedBlockSize = Platform::ConstPow2Pad(BlockSize); + // private data structure + struct QueueBlock + { + T data[kPaddedBlockSize]; + }; + + using QueueBlockPtr = QueueBlock*; + + QueueBlockPtr* m_pBlockIndexCache; + size_t m_numBlocks; + size_t m_offset; + size_t m_size; + AllocCb m_allocCb; + + // Private copy constructor to prevent implicit copies + Queue(const Queue& rhs) + : Queue(rhs.allocCb) + { + GrowBlocks(rhs.m_numBlocks); + for (int i = 0; i < rhs.m_size; i++) + { + *_AllocateBack() = rhs[i]; + } + } + + // Helper function to calculate the pBlockIndex index for the given index + size_t BlockForOffset(size_t offset) const + { + return ((offset / kPaddedBlockSize) & (m_numBlocks - 1)); + } + + // Helper function to calculate the index within a pBlockIndex for a given offset + size_t IndexForOffset(size_t offset) const + { + return ((offset % kPaddedBlockSize) & (kPaddedBlockSize - 1)); + } + + // Helper function to grow internal allocation by numBlocks blocks + void GrowBlocks(size_t numBlocks) + { + DD_STATIC_CONST size_t kPaddedCacheSize = Platform::ConstPow2Pad(MinIndexCacheSize); + + // Ensure the index offset is within the current capacity before resizing. While we treat the offset as + // a modulus cycle and otherwise allow this behavior, changing the capacity effectively changes the size + // of the modulus cycle and can invalidate offsets that are > Capacity(). Using a bitmask here only works + // because Capacity() is guaranteed to be a power of two. + m_offset &= (Capacity() - 1); + + // Calculate the new capacity as the next power of 2 above current number of blocks + numBlocks + const size_t newCapacity = Platform::Pow2Pad(Platform::Max(m_numBlocks + numBlocks, kPaddedCacheSize)); + + // Allocate a new pBlockIndex index cache + QueueBlockPtr* pNewIndexCache = + reinterpret_cast(DD_CALLOC(newCapacity * sizeof(QueueBlockPtr), + alignof(QueueBlockPtr), + m_allocCb)); + if (pNewIndexCache != nullptr) + { + + // If we had previously allocated a cache + if (m_numBlocks > 0) + { + // Calculate the pBlockIndex index for the current head of the queue + const size_t blockIndex = BlockForOffset(m_offset); + + // Calculate distance between the head and the end of the existing index cache + const size_t lengthToEnd = (m_numBlocks - blockIndex); + + QueueBlockPtr* basePtr = &pNewIndexCache[blockIndex]; + + // Copy pointers from head to the end of the existing allocation + increment pointer + memcpy(basePtr, &m_pBlockIndexCache[blockIndex], sizeof(QueueBlockPtr) * lengthToEnd); + basePtr += lengthToEnd; + + // Calculate difference in new capacity and previous capacity + const size_t count = newCapacity - m_numBlocks; + + // If there is enough room we copy objects from the beginning to the head after the tail + if (blockIndex <= count) + { + memcpy(basePtr, &m_pBlockIndexCache[0], sizeof(QueueBlockPtr) * blockIndex); + basePtr += blockIndex; + } + else + { + // Otherwise we need to split it into two memcpy's - the number that can fit at the end + // and the number that will have to go at the beginning + memcpy(basePtr, &m_pBlockIndexCache[0], sizeof(QueueBlockPtr) * count); + basePtr += count; + memcpy(&pNewIndexCache[0], &m_pBlockIndexCache[count], sizeof(QueueBlockPtr) * (blockIndex - count)); + } + // Free the original + DD_FREE(m_pBlockIndexCache, m_allocCb); + } + // Update the cache and the capacity + m_pBlockIndexCache = pNewIndexCache; + m_numBlocks = newCapacity; + } + } + + // Helper function to allocate memory for an object at the end of the queue + T* _AllocateBack() + { + T* pResult = nullptr; + const size_t newOffset = m_offset + m_size; + const size_t indexOffset = IndexForOffset(newOffset); + + // Check to see if the tail is at a pBlockIndex edge + grow as necessary + if ((indexOffset == 0) + & ((m_size + kPaddedBlockSize) >= Capacity())) + { + GrowBlocks(1); + } + + // Only allocate if we have enough space + if ((m_size + 1) <= Capacity()) + { + // Calculate the new capacity + const size_t blockOffset = BlockForOffset(newOffset); + DD_ASSERT(blockOffset < m_numBlocks); + QueueBlockPtr& pBlockIndex = m_pBlockIndexCache[blockOffset]; + + // If the pBlockIndex hasn't been allocated yet, allocate it + if (pBlockIndex == nullptr) + { + pBlockIndex = + static_cast(DD_MALLOC(sizeof(QueueBlock), alignof(QueueBlock), m_allocCb)); + DD_PRINT(LogLevel::Never, "[Queue::AllocateBack] Allocated block at 0x%X", pBlockIndex); + } + + // If the pBlockIndex has been allocated then get it's address + increment the size + if (pBlockIndex != nullptr) + { + DD_ASSERT(indexOffset < kPaddedBlockSize); + pResult = &pBlockIndex->data[indexOffset]; + m_size++; + } + } + return pResult; + } + + // Helper function to allocate memory for an object at the beginning of the queue + T* _AllocateFront() + { + T* pResult = nullptr; + + // Check to see if the head is at a pBlockIndex edge + grow as necessary + if ((IndexForOffset(m_offset) == 0) + & ((m_size + kPaddedBlockSize) >= Capacity())) + { + GrowBlocks(1); + } + + const size_t capacity = Capacity(); + // Only allocate if we have enough space + if ((m_size + 1) <= capacity) + { + // We need to wrap the index around if necessary + const size_t newOffset = (m_offset != 0 ? m_offset : capacity) - 1; + + // Calculate the pBlockIndex index + const size_t blockOffset = BlockForOffset(newOffset); + DD_ASSERT(blockOffset < m_numBlocks); + QueueBlockPtr& pBlockIndex = m_pBlockIndexCache[blockOffset]; + + // If the pBlockIndex hasn't been allocated yet, allocate it + if (pBlockIndex == nullptr) + { + pBlockIndex = + static_cast(DD_MALLOC(sizeof(QueueBlock), alignof(QueueBlock), m_allocCb)); + DD_PRINT(LogLevel::Never, "[Queue::AllocateFront] Allocated block at 0x%X", pBlockIndex); + } + + // If the pBlockIndex has been allocated then get it's address + increment the size + if (pBlockIndex != nullptr) + { + m_size++; + m_offset = newOffset; + const size_t indexOffset = IndexForOffset(newOffset); + DD_ASSERT(indexOffset < kPaddedBlockSize); + pResult = &pBlockIndex->data[indexOffset]; + } + } + return pResult; + } + + // + // EXTREMELY DANGEROUS INTERNAL CALLS + // + // These have no safety checking as they are assumed to only be used internally + // + + // Returns a reference to the object at the specified index. + // This *will* dereference an invalid pointer if you give it an invalid index. + T& _PeekIndex(size_t offset) const + { + const size_t index = m_offset + offset; + const size_t blockOffset = BlockForOffset(index); + DD_ASSERT(blockOffset < m_numBlocks); + const size_t indexOffset = IndexForOffset(index); + DD_ASSERT(indexOffset < kPaddedBlockSize); + + return m_pBlockIndexCache[blockOffset]->data[indexOffset]; + } + + // Returns a reference to the object at the back of the queue. + // This *will* dereference an invalid pointer if there are no objects in the queue. + T& _Back() const + { + return _PeekIndex(m_size - 1); + } + + // Returns a reference to the object at the front of the queue. + // This *will* dereference an invalid pointer if there are no objects in the queue. + T& _Front() const + { + return _PeekIndex(0); + } + + // Updates state so as to remove the last item in the queue. This does not actually destroy the object, + // and should only be called after that has occured. + // This *will* put the queue in an invalid state if called while the queue is empty. + void _PopBack() + { + DD_ASSERT(!IsEmpty()); + + if ((--m_size) == 0) + { + m_offset = 0; + } + } + + // Updates state so as to remove the first item in the queue. This does not actually destroy the object, + // and should only be called after that has occured. + // This *will* put the queue in an invalid state if called while the queue is empty. + void _PopFront() + { + DD_ASSERT(!IsEmpty()); + + m_offset++; + + if ((--m_size) == 0) + { + m_offset = 0; + } + } + }; + + // Iterator class for the Queue type + template + class Queue::Iterator + { + friend Queue; + public: + // Comparison operator + bool operator!=(const Iterator& rhs) const + { + return ((m_pContainer != rhs.m_pContainer) | (m_index != rhs.m_index)); + } + + // Prefix operator to increment the iterator + Iterator& operator++() + { + if (m_pContainer != nullptr) + { + m_index += 1; + if (m_index >= m_pContainer->m_size) + { + m_index = 0; + m_pContainer = nullptr; + } + } + return *this; + } + + // Indirection operator + T& operator*() const + { + DD_ASSERT(m_pContainer != nullptr); + return m_pContainer->_PeekIndex(m_index); + } + + // Member of pointer operator. Returns a pointer to the object in the shared container. + T* operator->() const + { + DD_ASSERT(m_pContainer != nullptr); + return &m_pContainer->_PeekIndex(m_index); + } + private: + // Private constructor so that an object cannot be created by the user + Iterator(const Queue* pContainer, size_t index) : + m_pContainer(pContainer), + m_index(index) + { + }; + + const Queue* m_pContainer; + size_t m_index; + }; + + // + // functions necessary for C++ ranged based for loop support + // + + // Implement begin() function for range-based for loops + template + inline typename Queue::Iterator + begin(Queue& rhs) + { + return rhs.Begin(); + } + + // Implement end() function for range-based for loops + template + inline constexpr typename Queue::Iterator + end(const Queue& rhs) + { + return rhs.End(); + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/util/sharedptr.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/util/sharedptr.h new file mode 100644 index 000000000..b970698ff --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/util/sharedptr.h @@ -0,0 +1,284 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file sharedptr.h +* @brief Template shared pointer class for gpuopen +*********************************************************************************************************************** +*/ + +#pragma once + +#include "ddPlatform.h" +#include "template.h" +#include "memory.h" + +namespace DevDriver +{ + // Helper structure that sets value to true if T is not abstract and is constructable using the provided + // arguments, otherwise it returns false. We use this to prevent the Create() function from being defined + // for classes that are not creatable. This in turn prevents code from being generated that causes + // Container to be defined, which leads to compile errors even if the client application never attempts + // to directly create an object of that type. + template + struct CanConstruct + { + DD_STATIC_CONST bool Value = !Platform::IsAbstract::Value && Platform::IsConstructible::Value; + }; + + // SharedPointerBase is the common parent class used by SharedPointer<> + // It implements common functions (e.g., pointer management) but cannot ever be + // used directly. The purpose of this separation is to enable SharedPointer to perform + // typecasts between derived and base types by casting through SharedPointerBase. + class SharedPointerBase + { + // SharedPointer is a subclass, but all need to have access to the protected + private members + template + friend class SharedPointer; + // public functions available to all subclasses + public: + // check to see if the class has been set + bool IsNull() const { return m_pObject == nullptr; } + + // clear the pointer and, if required, delete the underlying allocation + void Clear() + { + if (m_pContainer != nullptr) + { + if (m_pContainer->Release() == 0) + { + // ContainerBase has been declared with a virtual destructor, which guarantees + // that the specific ContainerBase subclass destructor is called + DD_DELETE(m_pContainer, m_pContainer->GetAllocCb()); + } + m_pContainer = nullptr; + m_pObject = nullptr; + } + } + + protected: + // Inner class that provides a standardized reference counted container interface + // Subclassed by SharedPointer to include an actual object + class ContainerBase + { + public: + // Construct container and initialize ref count to zero. This class should never be + // constructed directly by anything other than a subclass. + constexpr ContainerBase(const AllocCb &allocCb) + : m_allocCb(allocCb) + , m_refCount(0) + { + //DD_PRINT(LogLevel::Never, "Created reference counted container %i", m_refCount); + } + + // Destroy the container. Since this class is never directly created, this ensures + // subclasses (and the contained object) are always destroyed correctly. + virtual ~ContainerBase() + { + DD_ASSERT(m_refCount == 0); + DD_PRINT(LogLevel::Never, "Deleted reference counted container %i", m_refCount); + } + + // Increments the reference count of the container + int32 Retain(void) + { + DD_ASSERT(m_refCount >= 0); + int32 result = Platform::AtomicIncrement(&m_refCount); + DD_ASSERT(result >= 1); + DD_PRINT(LogLevel::Never, "Incremented reference count: %i", result); + return result; + } + + // Decrements the reference count of the container + int32 Release(void) + { + int32 result = Platform::AtomicDecrement(&m_refCount); + DD_ASSERT(result >= 0); + DD_PRINT(LogLevel::Never, "Decremented reference count: %i", result); + return result; + } + + // Retrieve the allocator callbacks so it can be destroyed + const AllocCb& GetAllocCb() const { return m_allocCb; } + private: + // Allocator callbacks + const AllocCb m_allocCb; + // Reference count + Platform::Atomic m_refCount; + + }; + + // Default constructor that is constexpr. Allows the compiler to inline this if it wants to. + constexpr SharedPointerBase() + : m_pContainer(nullptr) + , m_pObject(nullptr) + { + } + + // Initialize the object using the provided pointer + SharedPointerBase(ContainerBase* pContainer, void* pObject) + : m_pContainer(pContainer) + , m_pObject(pObject) + { + // We should always have a valid object if the container is valid. + DD_ASSERT((m_pContainer == nullptr) || (m_pObject != nullptr)); + + // If we have a valid container, increment the reference count. + if (m_pContainer != nullptr) + { + m_pContainer->Retain(); + } + } + + // Copy constructor copies the container pointer and increments the reference count + SharedPointerBase(const SharedPointerBase &right) + : SharedPointerBase(right.m_pContainer, right.m_pObject) + { + } + + // Move constructor takes the container pointer and clears the other container's pointer + SharedPointerBase(SharedPointerBase &&right) + : m_pContainer(Platform::Exchange(right.m_pContainer, nullptr)) + , m_pObject(Platform::Exchange(right.m_pObject, nullptr)) + { + } + + // On deletion of the object clear the pointer + ~SharedPointerBase() + { + Clear(); + } + private: + // Pointer to the shared container + ContainerBase* m_pContainer; + // Pointer to the object inside the shared container. We keep a copy of this to allow + // direct access to the object since we might not know the actual parent type of it. + void* m_pObject; + }; + + template + class SharedPointer : public SharedPointerBase + { + public: + // Create SharedPointer object with the default constructor + constexpr SharedPointer() : SharedPointerBase() {}; + + // Copy conversion constructor. Creates a new object if you can cast from type U to type T. + template ::Value>::Type> + SharedPointer(const SharedPointer &right) + : SharedPointerBase(Platform::Forward(right)) + { + } + + // Move conversion constructor. Takes ownership of the shared container if you can cast from type U to type T. + template ::Value>::Type> + SharedPointer(SharedPointer &&right) + : SharedPointerBase(Platform::Forward(right)) + { + } + + // Assignment operator to allow copy + swap idiom + SharedPointer &operator= (SharedPointer right) + { + m_pContainer = Platform::Exchange(right.m_pContainer, m_pContainer); + m_pObject = Platform::Exchange(right.m_pObject, m_pObject); + return *this; + } + + // Indirection operator. Returns a const reference to the object in the shared container. + // This operator is unsafe to use if the container hasn't been allocated. + T& operator*() const + { + DD_ASSERT(m_pObject != nullptr); + return *Get(); + } + + // Member of pointer operator. Returns a pointer to the object in the shared container. + // This operator is unsafe to use if the container hasn't been allocated. + T* operator->() const + { + DD_ASSERT(m_pObject != nullptr); + return Get(); + } + + // Templated comparison operator. Allows comparing shared pointer objects so long as U is convertable to T. + template ::Value>::Type> + bool operator== (const SharedPointer< U >&right) const + { + return m_pObject == right.m_pObject; + } + + // Templated comparison operator. Allows comparing shared pointer objects so long as U is convertable to T. + template ::Value>::Type> + bool operator!= (const SharedPointer< U >&right) const + { + return m_pObject != right.m_pObject; + } + + // Get a pointer to the contained object + T* Get() const + { + return static_cast(m_pObject); + } + + // Create a SharedPointer using the provided allocator callbacks and arguments + // This function is only valid if the class is not a valid class + template::Value>::Type> + static SharedPointer Create(const AllocCb& allocCb, Args&&... args) + { + SharedPointer result; + Container *pContainer = + DD_NEW(Container, allocCb)(allocCb, Platform::Forward(args)...); + + if (pContainer != nullptr) + { + result = SharedPointer(pContainer, &pContainer->m_object); + } + return result; + } + private: + // Templated Container class that inherents the type from the outer (SharedPointer) class + class Container : public ContainerBase + { + public: + // Constructor that initializes ContainerBase class and the object using the provided parameters + template + explicit constexpr Container(const AllocCb& allocCb, Args&&... args) + : ContainerBase(allocCb) + , m_object(Platform::Forward(args)...) + { + } + + // Actual object that the SharedPointer instance encapsulates + T m_object; + }; + + // Private constructor to allow direct initialization using an externally created Container + explicit SharedPointer(Container* pContainer, T* pObject) + : SharedPointerBase(static_cast(pContainer), pObject) + { + } + }; +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/util/template.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/util/template.h new file mode 100644 index 000000000..f20d07ee8 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/util/template.h @@ -0,0 +1,368 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file template.h +* @brief Templated utility functions +*********************************************************************************************************************** +*/ + +#pragma once + +#if !defined(_MSC_VER) +#include +#endif + +namespace DevDriver +{ + namespace Platform + { + /// Templated LockGuard class. Works with any type that implements Lock() and Unlock() + template + class LockGuard + { + public: + explicit LockGuard(T &lock) : m_lock(lock) { lock.Lock(); } + ~LockGuard() { m_lock.Unlock(); } + private: + T &m_lock; + }; + + /// Computes the base-2 logarithm of an unsigned 64-bit integer. + /// + /// If the given integer is not a power of 2, this function will not provide an exact answer. + /// + /// @returns log_2(u) + template + inline uint32 Log2(T u) ///< Value to compute the logarithm of. + { + uint32 logValue = 0; + + while (u > 1) + { + ++logValue; + u >>= 1; + } + return logValue; + } + + /// Computes the base-2 logarithm of an unsigned 64-bit integer. + /// + /// If the given integer is not a power of 2, this function will not provide an exact answer. + /// + /// @returns log_2(u) + template + inline constexpr uint32 _ConstLog2(T u, uint32 logValue) ///< Value to compute the logarithm of. + { + return (u > 1) ? _ConstLog2(u >> 1, logValue + 1) : logValue; + } + + /// Computes the base-2 logarithm of an unsigned 64-bit integer. + /// + /// If the given integer is not a power of 2, this function will not provide an exact answer. + /// + /// @returns log_2(u) + template + inline constexpr uint32 ConstLog2(T u) ///< Value to compute the logarithm of. + { + return _ConstLog2(u, 0); + } + + static_assert(ConstLog2(1) == 0, "ConstLog2 failure"); + static_assert(ConstLog2(2) == 1, "ConstLog2 failure"); + static_assert(ConstLog2(128) == 7, "ConstLog2 failure"); + static_assert(ConstLog2(255) == 7, "ConstLog2 failure"); + + /// Computes 2 ^ value provided + /// + /// @returns 2 ^ (u) + template + inline constexpr T Pow2(T u) + { + return ((T)1 << u); + } + + static_assert(Pow2(0) == 1, "Pow2 failure"); + static_assert(Pow2(1) == 2, "Pow2 failure"); + static_assert(Pow2(7) == 128, "Pow2 failure"); + + /// Determines if a value is a power of two. + /// + /// @returns True if it is a power of two, false otherwise. + inline constexpr bool IsPowerOfTwo(uint64 value) + { + return (value == 0) ? false : ((value & (value - 1)) == 0); + } + + /// Rounds the specified uint 'value' up to the nearest value meeting the specified 'alignment'. Only power of 2 + /// alignments are supported by this function. + /// + /// returns Aligned value. + template + inline constexpr T Pow2Align( + T value, ///< Value to align. + uint64 alignment) ///< Desired alignment (must be a power of 2). + { + return ((value + static_cast(alignment) - 1) & ~(static_cast(alignment) - 1)); + } + + /// Rounds the specified uint 'value' up to the nearest power of 2 + /// + /// @returns Power of 2 padded value. + template + inline T Pow2Pad(T value) ///< Value to pad. + { + T ret = 1; + if (IsPowerOfTwo(value)) + { + ret = value; + } + else + { + while (ret < value) + { + ret <<= 1; + } + } + + return ret; + } + + /// Rounds the specified uint 'value' up to the nearest power of 2. Constexpr varient. + /// + /// @returns Power of 2 padded value. + template + inline constexpr T _ConstPow2Pad(T value, T padded) ///< Value to pad. + { + return (padded < value) ? _ConstPow2Pad(value, padded << 1) : padded; + } + + /// Rounds the specified uint 'value' up to the nearest power of 2. Constexpr varient. + /// + /// @returns Power of 2 padded value. + template + inline constexpr T ConstPow2Pad(T value) ///< Value to pad. + { + return (IsPowerOfTwo(value)) ? value : _ConstPow2Pad(value, (T)1); + } + + static_assert(ConstPow2Pad(512) == 512, "ConstPow2Pad failure"); + static_assert(ConstPow2Pad(511) == 512, "ConstPow2Pad failure"); + static_assert(ConstPow2Pad(257) == 512, "ConstPow2Pad failure"); + + /// Finds the smallest of two values + /// + /// @returns a if a < b, otherwise b. + template + inline constexpr T Min(const T &a, const T &b) + { + return ((a < b) ? a : b); + } + + /// Finds the larger of two values + /// + /// @returns a if a > b, otherwise b. + template + inline constexpr T Max(const T &a, const T &b) + { + return ((a > b) ? a : b); + } + + // Given a type T, set Type equal to T + template + struct RemoveRef + { + typedef T Type; + }; + + // Given a type T&, set Type equal to T + template + struct RemoveRef + { + typedef T Type; + }; + + // Given a type T&&, set Type equal to T + template + struct RemoveRef + { + typedef T Type; + }; + + // std::move equivalent + template + inline typename RemoveRef::Type&& Move(T&& obj) + { + return static_cast::Type&&>(obj); + } + + // std::forward equivalent + template + inline T&& Forward(typename RemoveRef::Type&& args) + { + return static_cast(args); + } + + // std::forward equivalent + template + inline T&& Forward(typename RemoveRef::Type& args) + { + return static_cast(args); + } + + // Returns the contents of Value in a new variable, and assign newValue into the memory occupied by value. + template + inline T Exchange(T& value, U&& newValue) + { + T oldValue = Move(value); + value = Forward(newValue); + return (oldValue); + } + + // Convenience structure that defined Value as either true or false, and Type as either TrueType or FalseType + template + struct BoolType + { + static const bool Value = value; + using Type = BoolType; + }; + + using FalseType = BoolType; + using TrueType = BoolType; + + // Struct whose ::Type member is undefined if the first condition is not true + template + struct EnableIf + { + }; + + // Struct whose ::Type member is equal to T if the first condition is true. + template + struct EnableIf + { + typedef T Type; + }; + + template + struct IsPointer : FalseType + { + }; + + template + struct IsPointer : TrueType + { + }; + +// If we are building with MSVC we want to use the compiler intrinsics here. This is primarily because building with +// the /kernel precludes the use of the C++ type traits library. For all other compilers we simply implement this +// using the standard C++ library. +#if defined(_MSC_VER) + // Struct whose ::Value member is equal to true if you can cast from T to U, and false otherwise. + template + struct IsConvertible : BoolType<__is_convertible_to(T, U)> + { + }; + + // Struct whose ::Value member is equal to true if you can construct an object of type T using the arguments + // provided. + template + struct IsConstructible : BoolType<__is_constructible(T, Args...)> + { + + }; + + // Struct whose ::Value member is equal to true if T is an abstract class, and false otherwise. + template + struct IsAbstract : BoolType<__is_abstract(T)> + { + + }; + + // Struct whose ::Value member is equal to true if T is an abstract class, and false otherwise. + template + struct IsPod : BoolType<__is_pod(T)> + { + + }; + + // Struct whose ::Value member is equal to true if T is has a standard layout, and false otherwise. + template + struct IsStandardLayout : BoolType<__is_standard_layout(T)> + { + + }; + + // Struct whose ::Value member is equal to true if T is trivially destructable, and false otherwise. + template + struct IsTriviallyDestructible : BoolType<__has_trivial_destructor(T)> + { + + }; +#else + // Struct whose ::Value member is equal to true if you can cast from T to U, and false otherwise. + template + struct IsConvertible : BoolType::value> + { + + }; + + // Struct whose ::Value member is equal to true if you can construct an object of type T using the arguments + // provided. + template + struct IsConstructible : BoolType::value> + { + + }; + + // Struct whose ::Value member is equal to true if T is an abstract class, and false otherwise. + template + struct IsAbstract : BoolType::value> + { + + }; + + // Struct whose ::Value member is equal to true if T is an abstract class, and false otherwise. + template + struct IsPod : BoolType::value> + { + + }; + + // Struct whose ::Value member is equal to true if T is has a standard layout, and false otherwise. + template + struct IsStandardLayout : BoolType::value> + { + + }; + + // Struct whose ::Value member is equal to true if T is trivially destructable, and false otherwise. + template + struct IsTriviallyDestructible : BoolType::value> + { + + }; +#endif + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/util/vector.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/util/vector.h new file mode 100644 index 000000000..88909d2a7 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/util/vector.h @@ -0,0 +1,495 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file vector.h +* @brief Templated vector class for gpuopen +*********************************************************************************************************************** +*/ + +#pragma once + +#include "ddPlatform.h" +#include "template.h" +#include + +namespace DevDriver +{ + template + class Vector + { + public: + class Iterator; + + // Standard constructor + explicit Vector(const AllocCb& allocCb) + : m_pData(m_data) + , m_size(0) + , m_capacity(defaultCapacity) + , m_allocCb(allocCb) + { + } + + // Move constructor + Vector(Vector &&rhs) + : m_pData(m_data) // default initialize it to the default allocation + , m_size(Platform::Exchange(rhs.m_size, (size_t)0)) // move the rhs size value into ours + , m_capacity(defaultCapacity) // initialize the capacity to default + , m_allocCb(rhs.m_allocCb) // copy the allocator callback + { + // if the vector will fit inside the default allocation, move it into it + if (m_size < defaultCapacity) + { + for (size_t index = 0; index < m_size; index++) + { + m_data[index] = Platform::Move(rhs.m_pData[index]); + } + } + else // otherwise, we want to move the allocation + replace the capacity + { + m_pData = Platform::Exchange(rhs.m_pData, rhs.m_data); + m_capacity = Platform::Exchange(rhs.m_capacity, defaultCapacity); + } + } + + // Destructor + ~Vector() + { + Clear(); + } + + // Copy elision assignment operator. The compiler will decide whether to initialize the object via the move + // or copy constructor. This borders on "compiler magic" but is (alarmingly) valid since it relies on the fact + // that the compiler is able to generate a temporary copy of the parameter, then swaps contents of the current + // object with those from the temporary copy. The temporary copy is then destroyed, effectively destroying the + // the existing instance. Where things get weird is that the compiler, if the parameter is bound to an rvalue, + // is allowed to use it directly without making a temporary copy. This allows the compiler to simply treat the + // assignment as a swap, as opposed to having to copy all resources. The compiler is also allowed to do other + // optimizations based on context, so the actual behavior of this operator is somewhat squirrel. It does, + // however, allow implementing both the copy and move assignment operators with a single operator, relying + // on the compiler to pick a contextually appropriate behavior. + Vector& operator=(Vector rhs) + { + Swap(rhs); + return *this; + } + + // Convenience methods + size_t Size() const { return m_size; } + size_t Capacity() const { return m_capacity; } + bool IsEmpty() const { return (m_size == 0); } + + // Subscript operator + T& operator[](size_t index) { DD_ASSERT(index < m_size); return m_pData[index]; } + const T& operator[](size_t index) const { DD_ASSERT(index < m_size); return m_pData[index]; } + + // Insert elements into the back of the Vector + template + bool PushBack(Args&&... args) + { + bool result = false; + Reserve(m_size + 1); + if (m_size < m_capacity) + { + m_pData[m_size] = T(Platform::Forward(args)...); + ++m_size; + result = true; + } + return result; + } + + // Pop elements out of the Vector + bool PopBack(T* pData) + { + bool result = !IsEmpty(); + if (result) + { + --m_size; + if (pData != nullptr) + { + *pData = Platform::Move(m_pData[m_size]); + } + } + return result; + } + + // Pop elements out of the Vector + bool PopFront(T* pData) + { + bool result = !IsEmpty(); + if (result) + { + if (pData != nullptr) + { + *pData = Platform::Move(m_pData[0]); + } + + --m_size; + + if (m_size > 0) + { + for (size_t i = 0; i < m_size; i++) + { + m_pData[i] = Platform::Move(m_pData[i + 1]); + } + } + } + return result; + } + + // Remove the object at the specified index. Does not maintain order. + void Remove(size_t index) + { + DD_ASSERT((index < m_size) & (index >= 0)); + + const size_t lastIndex = m_size - 1; + + // If the index is the last index, we move the last element into it's place + if (index != lastIndex) + { + m_pData[index] = Platform::Move(m_pData[lastIndex]); + } + // Otherwise, if it is the last element and not a POD we replace it with a default constructed object + else if (!Platform::IsPod::Value) + { + m_pData[index] = T(); + } + + --m_size; + } + + // Remove all instances of the specified object from the vector. Does not maintain order. + size_t Remove(const T& object) + { + size_t numRemoved = 0; + + for (size_t index = m_size; index > 0; index--) + { + if (m_pData[index - 1] == object) + { + Remove(index - 1); + numRemoved++; + } + } + return numRemoved; + } + + // Free all memory + void Clear() + { + if (m_pData != m_data) + { + // If the object is not a POD we explicitly destroy all objects prior to freeing the allocation. + if (!Platform::IsPod::Value) + { + for (size_t i = 0; i < m_capacity; i++) + { + m_pData[i].~T(); + } + } + DD_FREE(m_pData, m_allocCb); + m_pData = m_data; + m_capacity = defaultCapacity; + m_size = 0; + } + else + { + Reset(); + } + } + + // Clears all objects stored, but doesn't free memory. + void Reset() + { + // If the object is not a POD we need to destroy all instances and replace them with default constructed + // instances. + if (!Platform::IsPod::Value) + { + for (size_t index = 0; index < m_size; index++) + { + m_pData[index] = T(); + } + } + m_size = 0; + } + + // Swaps the contents of the current vector with the provided vector + void Swap(Vector& rhs) + { + // If we can, we swap allocations directly + if ((m_pData != m_data) & (rhs.m_pData != rhs.m_data)) + { + m_pData = Platform::Exchange(rhs.m_pData, m_pData); + } + // Else if the other object is using the default allocation we move it's contents here + // and give ownership of our allocation to it + else if (m_pData != m_data) + { + for (size_t index = 0; index < rhs.m_size; index++) + { + m_data[index] = Platform::Move(rhs.m_data[index]); + } + rhs.m_pData = Platform::Exchange(m_pData, m_data); + } + // Else if this object is using the default allocation we move our data into it's allocation + // and take ownership of our allocation to it + else if (rhs.m_pData != rhs.m_data) + { + for (size_t index = 0; index < m_size; index++) + { + rhs.m_data[index] = Platform::Move(m_data[index]); + } + m_pData = Platform::Exchange(rhs.m_pData, rhs.m_data); + } + // Otherwise we just exchange all the objects that we need to + else + { + for (size_t index = 0; index < Platform::Max(m_size, rhs.m_size); index++) + { + m_data[index] = Platform::Exchange(rhs.m_data[index], m_data[index]); + } + } + + // Finally, we exchange the rest of the data + m_allocCb = Platform::Exchange(rhs.m_allocCb, m_allocCb); + m_capacity = Platform::Exchange(rhs.m_capacity, m_capacity); + m_size = Platform::Exchange(rhs.m_size, m_size); + } + + // Get a pointer to the beginning of the data + const T* Data() const + { + return m_pData; + } + + // Get a pointer to the beginning of the data + T* Data() + { + return m_pData; + } + + // Allocates enough memory to hold the specified number of elements + void Reserve(size_t newSize) + { + if (m_capacity < newSize) + { + const size_t newCapacity = Platform::Pow2Pad(Platform::Max(newSize, (size_t)1)); + const size_t allocSize = sizeof(T) * newCapacity; + T* pData = static_cast(DD_MALLOC(allocSize, alignof(T), m_allocCb)); + DD_ASSERT(pData != nullptr); + + // If the struct is not a POD, then we need to construct objects + if (!Platform::IsPod::Value) + { + size_t i = 0; + // First, we move all existing objects into the vector. + for (; i < m_size; i++) + { + new(&pData[i]) T(Platform::Move(m_pData[i])); + } + // Then we construct new objects with the remaining memory. + for (; i < newCapacity; i++) + { + new(&pData[i]) T(); + } + } + // Otherwise, we just copy the existing data into the new vector and call it good. + else + { + memcpy(&pData[0], &m_pData[0], sizeof(T) * m_size); + } + + if (m_pData != m_data) + { + // If the object wasn't a POD we need to destroy all instances before freeing the memory. + if (!Platform::IsPod::Value) + { + for (size_t i = 0; i < m_capacity; i++) + { + m_pData[i].~T(); + } + } + DD_FREE(m_pData, m_allocCb); + } + m_pData = pData; + m_capacity = newCapacity; + } + } + + // Resizes the vector. Implicitly destroys objects if newSize is smaller than the existing size. + void Resize(size_t newSize) + { + Reserve(newSize); + // If the object isn't a POD and we are shrinking the size, we need to replace destroyed objects with + // default constructed instances. + if (!Platform::IsPod::Value) + { + for (size_t i = newSize; i < m_size; i++) + { + m_pData[i] = T(); + } + } + m_size = newSize; + } + + // Iterator creation function + Iterator Begin() const + { + return CreateIterator(0); + } + + // Iterator creation function + constexpr Iterator End() const + { + return Iterator(nullptr, 0); + } + + // Iterator creation function + Iterator CreateIterator(size_t index) const + { + if (index < m_size) + return Iterator(this, index); + return End(); + } + + // Finds the first index for the provided object + Iterator Find(const T& object) const + { + auto it = Begin(); + for (; it != End(); ++it) + { + if (*it == object) + { + break; + } + } + return it; + } + + // Removes the element represented by the provided iterator. Does not maintain order. + Iterator Remove(const Iterator& it) + { + DD_ASSERT(it.m_pContainer == this); + + Remove(it.m_index); + if (it.m_index < m_size) + return it; + + return End(); + } + private: + // Private copy construct. Allows internal usage, but prevents accidental duplication. + Vector(Vector& rhs) + : m_pData(m_data) // default initialize it to the default allocation + , m_size((size_t)0) // initialize it to zero + , m_capacity(defaultCapacity) // initialize the capacity to default + , m_allocCb(rhs.m_allocCb) // copy the allocator callback + { + // reserve enough size to copy all the other data into it + Reserve(rhs.m_size); + // copy all values + for (; m_size < rhs.m_size; m_size++) + { + m_pData[index] = rhs.m_pData[index]; + } + } + + T m_data[defaultCapacity]; + T* m_pData; + size_t m_size; + size_t m_capacity; + AllocCb m_allocCb; + }; + + // Iterator class for the Vector type + template + class Vector::Iterator + { + friend Vector; + public: + // Comparison operator + bool operator!=(const Iterator& rhs) const + { + return ((m_pContainer != rhs.m_pContainer) | (m_index != rhs.m_index)); + } + + // Prefix operator to increment the iterator + Iterator& operator++() + { + if (m_pContainer != nullptr) + { + m_index += 1; + if (m_index >= m_pContainer->m_size) + { + m_index = 0; + m_pContainer = nullptr; + } + } + return *this; + } + + // Indirection operator + T& operator*() const + { + DD_ASSERT(m_pContainer != nullptr); + return m_pContainer->m_pData[m_index]; + } + + // Member of pointer operator. Returns a pointer to the object in the shared container. + T* operator->() const + { + DD_ASSERT(m_pContainer != nullptr); + return &m_pContainer->m_pData[m_index]; + } + private: + // Constructor is private to ensure it cannot be created by anything other than the Vector itself + Iterator(const Vector* pContainer, size_t index) : + m_pContainer(pContainer), + m_index(index) + { + }; + + const Vector* m_pContainer; + size_t m_index; + }; + + // + // functions necessary for C++ ranged based for loop support + // + + // Implement begin() function for range-based for loops + template + inline typename Vector::Iterator begin(Vector& rhs) + { + return rhs.Begin(); + } + + // Implement end() function for range-based for loops + template + inline constexpr typename Vector::Iterator end(const Vector& rhs) + { + return rhs.End(); + } + +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/win/ddWinPlatform.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/win/ddWinPlatform.h new file mode 100644 index 000000000..b0e4db7a4 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/inc/win/ddWinPlatform.h @@ -0,0 +1,148 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file ddWinPlatform.h +* @brief Windows platform layer definition +*********************************************************************************************************************** +*/ + +#pragma once + +#ifdef BUILDING_KD +#include "precomp.hpp" +#define DD_WINDOWS_KMD +#else +#define _CRT_RAND_S +#ifndef WIN32_LEAN_AND_MEAN +#define WIN32_LEAN_AND_MEAN +#include +#undef WIN32_LEAN_AND_MEAN +#else +#include +#endif +#endif + +#if defined(_MSC_VER) +#include +#else +#include +#endif + +#define DD_RESTRICT __restrict + +#define DD_WINDOWS + +namespace DevDriver +{ + namespace Platform + { + /* platform functions for performing atomic operations */ + typedef volatile long Atomic; + DD_CHECK_SIZE(Atomic, sizeof(int32)); + + struct EmptyStruct {}; + +#ifdef DD_WINDOWS_KMD + + struct MutexStorage + { + FAST_MUTEX mutex; +#if !defined(NDEBUG) + Atomic lockCount; +#endif + }; + typedef KSEMAPHORE SemaphoreStorage; + typedef KEVENT EventStorage; + typedef ULONG RandomStorage; +#else + struct MutexStorage + { + CRITICAL_SECTION criticalSection; +#if !defined(NDEBUG) + Atomic lockCount; +#endif + }; + typedef Handle SemaphoreStorage; + typedef HANDLE EventStorage; + typedef EmptyStruct RandomStorage; +#endif + struct ThreadStorage + { + void(*callback)(void *); + void *parameter; + volatile HANDLE handle; + }; + + // Either invoke the debugger or raise the TRAP + __declspec(noreturn) inline static void DebugBreak( + const char* pFile, + unsigned int line, + const char* pFunction, + const char* pAssertion) + { + DD_UNUSED(pFile); + DD_UNUSED(line); + DD_UNUSED(pFunction); + DD_UNUSED(pAssertion); +#ifdef DEVDRIVER_HARD_ASSERT +#if defined(_MSC_VER) + __debugbreak(); +#else + raise(SIGTRAP); +#endif +#endif + } + + namespace Windows + { + + // Windows specific functions required for in-memory communication + Result AcquireFastLock(Atomic *mutex); + Result ReleaseFastLock(Atomic *mutex); + + Handle CreateSharedSemaphore(uint32 initialCount, uint32 maxCount); + Handle CopySemaphoreFromProcess(ProcessId processId, Handle hObject); + Result SignalSharedSemaphore(Handle pSemaphore); + Result WaitSharedSemaphore(Handle pSemaphore, uint32 millisecTimeout); + void CloseSharedSemaphore(Handle pSemaphore); + + Handle CreateSharedBuffer(Size bufferSizeInBytes); + void CloseSharedBuffer(Handle hSharedBuffer); + + Handle MapSystemBufferView(Handle hBuffer, Size bufferSizeInBytes); + Handle MapProcessBufferView(Handle hBuffer, ProcessId processId); + void UnmapBufferView(Handle hSharedBuffer, Handle hSharedBufferView); + + class AtomicLockGuard + { + public: + explicit AtomicLockGuard(Atomic &lock) : m_lock(lock) { AcquireFastLock(&m_lock); }; + ~AtomicLockGuard() { ReleaseFastLock(&m_lock); }; + private: + Atomic &m_lock; + }; + } + } +} diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/clientmanagers/abstractClientManager.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/clientmanagers/abstractClientManager.h new file mode 100644 index 000000000..c53585c71 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/clientmanagers/abstractClientManager.h @@ -0,0 +1,70 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file abstractClientManager.h +* @brief Class declaration for IClientManager +*********************************************************************************************************************** +*/ + +#pragma once + +#include "gpuopen.h" +#include "../transports/abstractListenerTransport.h" +#include + +namespace DevDriver +{ + class IClientManager + { + public: + virtual ~IClientManager() {} + + // TODO: explicit initialize and destroy? + // anything else missing? + virtual Result RegisterHost(ClientId* pClientId) = 0; + virtual std::shared_ptr GetHostTransport() = 0; + virtual Result UnregisterHost() = 0; + +#if DD_VERSION_SUPPORTS(GPUOPEN_DEPRECATE_LEGACY_KMD_VERSION) + virtual Result RegisterClient(ClientId* pClientId) = 0; +#else + virtual Result RegisterClient(Component componentType, StatusFlags flags, ClientId* pClientId) = 0; +#endif + virtual Result UnregisterClient(ClientId clientId) = 0; + +#if !DD_VERSION_SUPPORTS(GPUOPEN_DISTRIBUTED_STATUS_FLAGS_VERSION) + virtual Result UpdateHostStatus(StatusFlags flags) = 0; + virtual Result UpdateClientStatus(ClientId clientId, StatusFlags flags) = 0; + virtual Result QueryStatus(StatusFlags *pFlags) = 0; +#endif + + virtual const char *GetClientManagerName() const = 0; + virtual ClientId GetHostClientId() const = 0; + + protected: + IClientManager() {} + }; + +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/clientmanagers/listenerClientManager.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/clientmanagers/listenerClientManager.cpp new file mode 100644 index 000000000..f49dcddec --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/clientmanagers/listenerClientManager.cpp @@ -0,0 +1,232 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "listenerClientManager.h" +#include "ddPlatform.h" +#include + +namespace DevDriver +{ + ListenerClientManager::ListenerClientManager(const AllocCb& allocCb, const ListenerClientManagerInfo& clientManagerInfo) : + m_clientManagerInfo(clientManagerInfo), + m_initialized(false), + m_hostClientId(kBroadcastClientId), + m_clientMutex(), + m_clientInfo(allocCb), +#if !DD_VERSION_SUPPORTS(GPUOPEN_DEPRECATE_LEGACY_KMD_VERSION) + m_combinedStatusFlags(static_cast(ClientStatusFlags::None)), +#endif + m_rand() + { + DD_ASSERT((clientManagerInfo.routerPrefix & + clientManagerInfo.routerPrefixMask) == clientManagerInfo.routerPrefix); + } + + ListenerClientManager::~ListenerClientManager() + { + if (m_initialized) + UnregisterHost(); + } + + Result ListenerClientManager::RegisterHost(ClientId* pClientId) + { + Result result = Result::Error; + if (!m_initialized) + { + Platform::LockGuard clientLock(m_clientMutex); + + m_hostClientId = GenerateClientId(); + DD_ASSERT(m_hostClientId != kBroadcastClientId); + m_initialized = true; + *pClientId = m_hostClientId; +#if DD_VERSION_SUPPORTS(GPUOPEN_DEPRECATE_LEGACY_KMD_VERSION) + m_clientInfo.Insert(m_hostClientId); +#else + m_clientInfo[m_hostClientId].status = 0; + m_clientInfo[m_hostClientId].componentType = Component::Server; + RecalculateClientStatus(); +#endif + result = Result::Success; + } + return result; + } + +#if !DD_VERSION_SUPPORTS(GPUOPEN_DISTRIBUTED_STATUS_FLAGS_VERSION) + Result ListenerClientManager::UpdateHostStatus(StatusFlags flags) + { + Result result = Result::Error; + if (m_initialized) + { + Platform::LockGuard clientLock(m_clientMutex); + m_clientInfo[m_hostClientId].status = flags; + RecalculateClientStatus(); + result = Result::Success; + } + return result; + } +#endif + + Result ListenerClientManager::UnregisterHost() + { + Result result = Result::Error; + if (m_initialized) + { + Platform::LockGuard clientLock(m_clientMutex); + m_clientInfo.Clear(); + m_hostClientId = kBroadcastClientId; +#if !DD_VERSION_SUPPORTS(GPUOPEN_DEPRECATE_LEGACY_KMD_VERSION) + RecalculateClientStatus(); +#endif + m_initialized = false; + result = Result::Success; + } + return result; + } + +#if DD_VERSION_SUPPORTS(GPUOPEN_DEPRECATE_LEGACY_KMD_VERSION) + Result ListenerClientManager::RegisterClient(ClientId* pClientId) +#else + Result ListenerClientManager::RegisterClient(Component componentType, StatusFlags flags, ClientId* pClientId) +#endif + { + Result result = Result::Error; + if (m_initialized) + { + Platform::LockGuard clientLock(m_clientMutex); + + const ClientId tempClientId = GenerateClientId(); + if (tempClientId != kBroadcastClientId) + { + const ClientId clientMask = ~m_clientManagerInfo.routerPrefixMask; + DD_ASSERT((tempClientId & clientMask) != kBroadcastClientId); +#if DD_VERSION_SUPPORTS(GPUOPEN_DEPRECATE_LEGACY_KMD_VERSION) + m_clientInfo.Insert(tempClientId); +#else + ClientInfo newClientInfo = {}; + newClientInfo.componentType = componentType; + newClientInfo.status = flags; + m_clientInfo.Create(tempClientId, newClientInfo); + RecalculateClientStatus(); +#endif + *pClientId = tempClientId; + result = Result::Success; + } + else + { + // This is a critical failure and shouldn't happen under normal conditions + DD_ALERT_REASON("Client manager was unable to generate a new client ID"); + } + } + return result; + } + + Result ListenerClientManager::UnregisterClient(ClientId clientId) + { + Result result = Result::Error; + if (m_initialized & (clientId != m_hostClientId)) + { + Platform::LockGuard clientLock(m_clientMutex); + // Attempt to erase a client with the specified client ID. If >0 we have successfully removed + // the client ID from the set. + if (m_clientInfo.Erase(clientId) == Result::Success) + { +#if !DD_VERSION_SUPPORTS(GPUOPEN_DEPRECATE_LEGACY_KMD_VERSION) + RecalculateClientStatus(); +#endif + result = Result::Success; + } + } + return result; + } + +#if !DD_VERSION_SUPPORTS(GPUOPEN_DISTRIBUTED_STATUS_FLAGS_VERSION) + Result ListenerClientManager::UpdateClientStatus(ClientId clientId, StatusFlags flags) + { + Result result = Result::Error; + if (m_initialized & (clientId != m_hostClientId)) + { + Platform::LockGuard clientLock(m_clientMutex); + auto find = m_clientInfo.Find(clientId); + if (find != m_clientInfo.End()) + { + find->value.status = flags; + result = Result::Success; + RecalculateClientStatus(); + } + } + return result; + } + + Result ListenerClientManager::QueryStatus(StatusFlags *pFlags) + { + Result result = Result::Error; + if (m_initialized) + { + *pFlags = m_combinedStatusFlags; + result = Result::Success; + } + return result; + } +#endif + +#if !DD_VERSION_SUPPORTS(GPUOPEN_DEPRECATE_LEGACY_KMD_VERSION) + bool ListenerClientManager::RecalculateClientStatus() + { + const StatusFlags originalFlags = m_combinedStatusFlags; + m_combinedStatusFlags = static_cast(ClientStatusFlags::None); + for (auto &client : m_clientInfo) + { + m_combinedStatusFlags |= client.value .status; + } + + return (m_combinedStatusFlags != originalFlags); + } +#endif + + // Generate a random client ID that has not already been allocated + ClientId ListenerClientManager::GenerateClientId() + { + ClientId tempClientId = kBroadcastClientId; + + const ClientId routerPrefix = m_clientManagerInfo.routerPrefix; + const ClientId clientMask = ~m_clientManagerInfo.routerPrefixMask; + + // The maximum number of clients we can allocate is equal the client ID mask, less one for the broadcast ID + DD_STATIC_CONST size_t kMaxNumberOfClients = (kClientIdMask - 1); + + if (m_clientInfo.Size() < kMaxNumberOfClients) + { + // Loop until we have found a client ID that is not the broadcast client ID and that we haven't allocated + do + { + // Add one since the range is typically 0 <= x < Max + const uint32 randVal = m_rand.Generate() + 1; + tempClientId = static_cast(randVal & clientMask) | routerPrefix; + } while (((tempClientId & clientMask) == kBroadcastClientId) || m_clientInfo.Contains(tempClientId)); + } + + DD_ASSERT(tempClientId != kBroadcastClientId); + return tempClientId; + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/clientmanagers/listenerClientManager.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/clientmanagers/listenerClientManager.h new file mode 100644 index 000000000..1d32dbd0a --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/clientmanagers/listenerClientManager.h @@ -0,0 +1,105 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file abstractClientManager.h +* @brief Class declaration for IClientManager +*********************************************************************************************************************** +*/ + +#pragma once + +#include "gpuopen.h" +#include "abstractClientManager.h" +#if DD_VERSION_SUPPORTS(GPUOPEN_DEPRECATE_LEGACY_KMD_VERSION) +#include "util/hashSet.h" +#else +#include "util/hashMap.h" +#endif +#include "ddPlatform.h" + +namespace DevDriver +{ + struct ListenerClientManagerInfo + { + ClientId routerPrefix; + ClientId routerPrefixMask; + }; + + class ListenerClientManager : public IClientManager + { + public: + ListenerClientManager(const AllocCb& allocCb, const ListenerClientManagerInfo& clientManagerInfo); + ~ListenerClientManager(); + + // TODO: explicit initialize and destroy? + // anything else missing? + + Result RegisterHost(ClientId* pClientId) override; + std::shared_ptr GetHostTransport() override { return std::shared_ptr(); }; + Result UnregisterHost() override; + +#if DD_VERSION_SUPPORTS(GPUOPEN_DEPRECATE_LEGACY_KMD_VERSION) + Result RegisterClient(ClientId* pClientId) override; +#else + Result RegisterClient(Component componentType, StatusFlags flags, ClientId* pClientId) override; +#endif + Result UnregisterClient(ClientId clientId) override; + +#if !DD_VERSION_SUPPORTS(GPUOPEN_DISTRIBUTED_STATUS_FLAGS_VERSION) + Result UpdateHostStatus(StatusFlags flags) override; + Result UpdateClientStatus(ClientId clientId, StatusFlags flags) override; + Result QueryStatus(StatusFlags *pFlags) override; +#endif + const char *GetClientManagerName() const override { return "Internal"; }; + ClientId GetHostClientId() const override { return (m_initialized ? m_hostClientId : kBroadcastClientId); }; + + protected: +#if !DD_VERSION_SUPPORTS(GPUOPEN_DEPRECATE_LEGACY_KMD_VERSION) + struct ClientInfo + { + StatusFlags status; + Component componentType; + }; +#endif + + const ListenerClientManagerInfo m_clientManagerInfo; + bool m_initialized; + ClientId m_hostClientId; + Platform::Mutex m_clientMutex; +#if DD_VERSION_SUPPORTS(GPUOPEN_DEPRECATE_LEGACY_KMD_VERSION) + HashSet m_clientInfo; +#else + HashMap m_clientInfo; + StatusFlags m_combinedStatusFlags; +#endif + Platform::Random m_rand; + +#if !DD_VERSION_SUPPORTS(GPUOPEN_DEPRECATE_LEGACY_KMD_VERSION) + bool RecalculateClientStatus(); +#endif + ClientId GenerateClientId(); + }; + +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/ddListenerURIService.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/ddListenerURIService.cpp new file mode 100644 index 000000000..1a7e49edd --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/ddListenerURIService.cpp @@ -0,0 +1,182 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "ddListenerURIService.h" +#include "msgChannel.h" +#include "ddTransferManager.h" +#include "listenerCore.h" + +namespace DevDriver +{ + // ===================================================================================================================== + ListenerURIService::ListenerURIService() + : m_pListenerCore(nullptr) + { + } + + // ===================================================================================================================== + ListenerURIService::~ListenerURIService() + { + } + + // ===================================================================================================================== + Result ListenerURIService::HandleRequest(URIRequestContext* pContext) + { + DD_ASSERT(pContext != nullptr); + + Result result = Result::Error; + + // We can only handle requests if a valid listener core has been bound. + if (m_pListenerCore != nullptr) + { + // We currently only handle the "info" command. + // All other commands will result in an error. + if (strcmp(pContext->pRequestArguments, "clients") == 0) + { + // Get a list of all currently connected clients. + const std::vector connectedClients = m_pListenerCore->GetConnectedClientList(); + + // @todo: Replace with a string builder utility class. + char textBuffer[256]; + + // Write all the info into the response block as plain text. + auto& pBlock = pContext->pResponseBlock; + + // Write the header + Platform::Snprintf(textBuffer, sizeof(textBuffer), "--- %u Connected Clients ---", static_cast(connectedClients.size())); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + for (uint32 clientIndex = 0; clientIndex < static_cast(connectedClients.size()); ++clientIndex) + { + const ClientInfo& clientInfo = connectedClients[clientIndex]; + + // Write the client header + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\n\n--- Client %u ---", clientIndex); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + // Write the name + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nName: %s", clientInfo.clientName); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + // Write the description + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nDescription: %s", clientInfo.clientDescription); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + // Write the process id + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nProcess Id: %u", clientInfo.clientPid); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + // Write the client id + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nClient Id: %u", static_cast(clientInfo.clientId)); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + // Write has been identified + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nHas Been Identified: %u", static_cast(clientInfo.hasBeenIdentified)); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + } + + pContext->responseDataFormat = URIDataFormat::Text; + + result = Result::Success; + } + else if (strcmp(pContext->pRequestArguments, "transports") == 0) + { + // Get a list of all currently managed transports. + const std::vector>& managedTransports = m_pListenerCore->GetManagedTransports(); + + // @todo: Replace with a string builder utility class. + char textBuffer[256]; + + // Write all the info into the response block as plain text. + auto& pBlock = pContext->pResponseBlock; + + // Write the header + Platform::Snprintf(textBuffer, sizeof(textBuffer), "--- %u Transports ---", static_cast(managedTransports.size())); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + for (uint32 transportIndex = 0; transportIndex < static_cast(managedTransports.size()); ++transportIndex) + { + const std::shared_ptr& transport = managedTransports[transportIndex]; + + // Write the transport header + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\n\n--- Transport %u ---", transportIndex); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + // Write the name + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nName: %s", transport->GetTransportName()); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + // Write the handle + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nHandle: %u", transport->GetHandle()); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + // Write the description + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nIs Forwarding Connection: %u", static_cast(transport->ForwardingConnection())); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + } + + pContext->responseDataFormat = URIDataFormat::Text; + + result = Result::Success; + } + else if (strcmp(pContext->pRequestArguments, "info") == 0) + { + // @todo: Replace with a string builder utility class. + char textBuffer[256]; + + // Write all the info into the response block as plain text. + auto& pBlock = pContext->pResponseBlock; + + const IClientManager* pClientManager = m_pListenerCore->GetClientManager(); + const ListenerCreateInfo& createInfo = m_pListenerCore->GetCreateInfo(); + + // Write the listener description + Platform::Snprintf(textBuffer, sizeof(textBuffer), "Listener Description: %s", createInfo.description); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + // Write the listener UWP flag + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nListener UWP Support: %u", static_cast(createInfo.flags.enableUWP)); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + // Write the listener server flag + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nListener Server Support: %u", static_cast(createInfo.flags.enableServer)); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + // Write the name of the client manager + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nClient Manager Name: %s", pClientManager->GetClientManagerName()); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + // Write the host client id of the client manager + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nClient Manager Host Client Id: %u", static_cast(pClientManager->GetHostClientId())); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + pContext->responseDataFormat = URIDataFormat::Text; + + result = Result::Success; + } + } + + return result; + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/ddListenerURIService.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/ddListenerURIService.h new file mode 100644 index 000000000..3af068b78 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/ddListenerURIService.h @@ -0,0 +1,62 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file ddListenerURIService.h +* @brief Class declaration for ListenerURIService +*********************************************************************************************************************** +*/ + +#pragma once + +#include "protocols/ddURIService.h" + +namespace DevDriver +{ + class ListenerCore; + + // String used to identify the listener URI service + DD_STATIC_CONST char kListenerURIServiceName[] = "listener"; + + class ListenerURIService : public IService + { + public: + ListenerURIService(); + ~ListenerURIService(); + + // Returns the name of the service + const char* GetName() const override final { return kListenerURIServiceName; } + + // Binds a listener core to the service + // All requests will be handled using the currently bound listener core + void BindListenerCore(ListenerCore* pListenerCore) { m_pListenerCore = pListenerCore; } + + // Handles an incoming URI request + Result HandleRequest(URIRequestContext* pContext) override final; + + private: + // Currently bound listener core + ListenerCore* m_pListenerCore; + }; +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/hostMsgTransport.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/hostMsgTransport.cpp new file mode 100644 index 000000000..106c22e55 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/hostMsgTransport.cpp @@ -0,0 +1,90 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "hostMsgTransport.h" +#include "transports/hostTransport.h" +#include "ddPlatform.h" + +#define BUFFER_LENGTH 16 +#define RECV_BUFSIZE (sizeof(MessageBuffer) * 8) +#define SEND_BUFSIZE (sizeof(MessageBuffer) * 8) + +namespace DevDriver +{ + HostMsgTransport::HostMsgTransport(const std::shared_ptr &pHostTransport, + ClientId hostClientId) + : m_clientId(hostClientId) + , m_pHostTransport(pHostTransport) + { + } + + HostMsgTransport::~HostMsgTransport() + { + } + + Result HostMsgTransport::Connect(ClientId *pClientId, uint32 timeoutInMs) + { + DD_UNUSED(timeoutInMs); + + Result result = Result::Error; + if (m_clientId != kBroadcastClientId) + { + // we don't have to register the client, as client registration for the is done HostMsgTransport elsewhere + result = Result::Success; + *pClientId = m_clientId; + } + return result; + } + + Result HostMsgTransport::Disconnect() + { + Result result = Result::Error; + if (m_clientId != kBroadcastClientId) + { + // we don't have to unregister the client, as client registration for the HostMsgTransport elsewhere + result = Result::Success; + m_clientId = kBroadcastClientId; + } + return result; + } + + Result HostMsgTransport::ReadMessage(MessageBuffer &messageBuffer, uint32 timeoutInMs) + { + return m_pHostTransport->HostReadMessage(messageBuffer, timeoutInMs); + } + + Result HostMsgTransport::WriteMessage(const MessageBuffer &messageBuffer) + { + return m_pHostTransport->HostWriteMessage(messageBuffer); + } + +#if !DD_VERSION_SUPPORTS(GPUOPEN_DISTRIBUTED_STATUS_FLAGS_VERSION) + Result HostMsgTransport::UpdateClientStatus(ClientId clientId, StatusFlags flags) + { + DD_UNUSED(clientId); + DD_UNUSED(flags); + return Result::Error; + } +#endif +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/hostMsgTransport.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/hostMsgTransport.h new file mode 100644 index 000000000..aa0d74fb8 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/hostMsgTransport.h @@ -0,0 +1,76 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file udpListenerTransport.h +* @brief Class declaration for BaseMsgChannel +*********************************************************************************************************************** +*/ + +#pragma once + +#include "transports/abstractListenerTransport.h" +#include "../inc/msgTransport.h" +#include + +namespace DevDriver +{ + class HostListenerTransport; + + class HostMsgTransport : public IMsgTransport + { + public: + HostMsgTransport(const std::shared_ptr &pHostTransport, + ClientId hostClientId); + ~HostMsgTransport(); + + Result Connect(ClientId* pClientId, uint32 timeoutInMs) override; + Result Disconnect() override; + + Result ReadMessage(MessageBuffer &messageBuffer, uint32 timeoutInMs) override; + Result WriteMessage(const MessageBuffer &messageBuffer) override; + + const char* GetTransportName() const override + { + return "Direct Connection"; + } + +#if !DD_VERSION_SUPPORTS(GPUOPEN_DISTRIBUTED_STATUS_FLAGS_VERSION) + Result UpdateClientStatus(ClientId clientId, StatusFlags flags) override; +#endif + + DD_STATIC_CONST bool RequiresKeepAlive() + { + return false; + } + + DD_STATIC_CONST bool RequiresClientRegistration() + { + return true; + } + private: + ClientId m_clientId; + std::shared_ptr m_pHostTransport; + }; +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/listenerCore.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/listenerCore.cpp new file mode 100644 index 000000000..b416da921 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/listenerCore.cpp @@ -0,0 +1,366 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file listenerCore.cpp +* @brief Class definition for ListenerCore +*********************************************************************************************************************** +*/ + +#include "listenerCore.h" +#include +#include "../inc/ddPlatform.h" + +#ifdef _WIN32 +#include "transports/winPipeTransport.h" +#endif +#include "transports/socketTransport.h" +#include "transports/hostTransport.h" +#include "clientmanagers/listenerClientManager.h" +#include "../src/messageChannel.h" +#include "hostMsgTransport.h" + +#include "listenerServer.h" +#include "../inc/protocols/loggingServer.h" +#include "../inc/protocols/loggingProtocol.h" + +#include + +#ifdef RDS_LOG_TO_PANEL +#include "../Common/ToolUtil.h" +#endif + +namespace DevDriver +{ + // Static pointer to a logging server for use by the LogMessage function + static LoggingProtocol::LoggingServer* pLogServer = nullptr; + + // Client manager routing prefix + DD_STATIC_CONST ClientId kListenerClientManagerPrefix = (0x0000) & kRouterPrefixMask; + + // ===================================================================================================================== + // Logs a message to the console or the logging server if it's available + void LogMessage(LogLevel logLevel, const char *format, ...) + { + char message[1024]; + va_list args; + va_start(args, format); +#if defined(_WIN32) + vsprintf_s(message, format, args); +#else + vsprintf(message, format, args); +#endif + va_end(args); + if (pLogServer != nullptr) + { + using namespace DevDriver::LoggingProtocol; + pLogServer->Log(logLevel, kGeneralCategoryMask, message); + } + +#ifdef RDS_LOG_TO_PANEL + ToolUtil::DbgMsg(message); +#else + Platform::DebugPrint(logLevel, message); +#endif + } + + // ===================================================================================================================== + // Constructs a vector of the currently connected clients and returns it + std::vector ListenerCore::GetConnectedClientList() + { + return m_routerCore.GetConnectedClientList(); + } + + // ===================================================================================================================== + // Constructor + ListenerCore::ListenerCore() : + m_createInfo(), + m_routerCore(), + m_pClientManager(nullptr), + m_started(false), + m_pMsgChannel(nullptr), + m_pServer(nullptr) + { + } + + // ===================================================================================================================== + // Destructor + ListenerCore::~ListenerCore() + { + Destroy(); + } + + // ===================================================================================================================== + // Initializes the listener core object and binds to all provided addresses + Result ListenerCore::Initialize(ListenerCreateInfo& createInfo) + { + DD_ASSERT(m_pClientManager == nullptr); + DD_ASSERT(m_pMsgChannel == nullptr); + + Result result = Result::Unavailable; + + std::lock_guard lock(m_routerMutex); + + if (m_pClientManager == nullptr) + { + ListenerClientManagerInfo infoStruct = {}; + infoStruct.routerPrefix = kListenerClientManagerPrefix; + infoStruct.routerPrefixMask = 0; + + IClientManager *pClientManager = new ListenerClientManager(createInfo.allocCb, infoStruct); + if (m_routerCore.SetClientManager(pClientManager) == Result::Success) + { + m_pClientManager = pClientManager; + } + else + { + delete pClientManager; + } + } + + if (m_pClientManager != nullptr) + { +#ifdef _WIN32 + auto pPipeTransport = std::make_shared(kDefaultNamedPipe.hostname); +#else + auto pPipeTransport = std::make_shared(kDefaultNamedPipe.type, + kDefaultNamedPipe.hostname, + kDefaultNamedPipe.port); +#endif + if (m_routerCore.RegisterTransport(pPipeTransport) == Result::Success) + { + m_managedTransports.emplace_back(pPipeTransport); + } + + for (uint32 i = 0; i < createInfo.numAddresses; i++) + { + // todo: validate this. + ListenerBindAddress &address = createInfo.pAddressesToBind[i]; + + auto pRemoteTransport = std::make_shared(TransportType::Remote, + address.hostAddress, + address.port); + if (m_routerCore.RegisterTransport(pRemoteTransport) == Result::Success) + { + m_managedTransports.emplace_back(pRemoteTransport); + } + } + } + + DD_ASSERT(m_pClientManager != nullptr); + + if ((m_pClientManager != nullptr) && ((m_managedTransports.size() > 0) || (m_pClientManager->GetHostTransport() != nullptr))) + { + + if (createInfo.flags.enableServer) + { + std::shared_ptr pLoopbackTransport = std::make_shared(createInfo); + if (pLoopbackTransport != nullptr && m_routerCore.RegisterTransport(pLoopbackTransport) == Result::Success) + { + ClientId hostClientId = m_pClientManager->GetHostClientId(); + + MessageChannelCreateInfo channelCreateInfo = {}; + Platform::Strncpy(channelCreateInfo.clientDescription, + createInfo.description, + sizeof(channelCreateInfo.clientDescription)); + channelCreateInfo.createUpdateThread = true; + channelCreateInfo.componentType = Component::Server; + m_pMsgChannel = new MessageChannel(createInfo.allocCb, + channelCreateInfo, + pLoopbackTransport, + hostClientId); + if (m_pMsgChannel != nullptr) + { + m_pServer = new ListenerServer(createInfo.serverCreateInfo, m_pMsgChannel); + m_managedTransports.emplace_back(pLoopbackTransport); + } + } + } + + DD_PRINT(LogLevel::Info, "[ListenerCore] Using %s client manager", m_pClientManager->GetClientManagerName()); + for (const auto &pTransport : m_managedTransports) + { + DD_PRINT(LogLevel::Info, "[ListenerCore] Listening for connections on %s", pTransport->GetTransportName()); + } + + RouterStartInfo startInfo = {}; + Platform::Strncpy(startInfo.description, createInfo.description, sizeof(startInfo.description)); + + if (m_routerCore.Start(startInfo) == Result::Success) + { + if (m_pServer != nullptr) + { + if (m_pServer->Initialize() == Result::Success) + { + pLogServer = m_pServer->GetLoggingServer(); + + // Bind the listener core object to the listener URI service. + m_listenerURIService.BindListenerCore(this); + + // Register the listener URI service. + m_pMsgChannel->RegisterService(&m_listenerURIService); + } + else + { + m_pServer->Destroy(); + delete m_pServer; + m_pServer = nullptr; + } + } + + m_createInfo = createInfo; + result = Result::Success; + m_started = true; + } + } + + DD_ASSERT(m_started); + + if (!m_started) + { + + if (m_pServer != nullptr) + { + pLogServer = nullptr; + m_pServer->Destroy(); + delete m_pServer; + m_pServer = nullptr; + } + + if (m_pMsgChannel != nullptr) + { + m_pMsgChannel->Unregister(); + delete m_pMsgChannel; + m_pMsgChannel = nullptr; + } + + for (const auto &pTransport : m_managedTransports) + { + m_routerCore.RemoveTransport(pTransport); + } + m_managedTransports.clear(); + m_routerCore.Stop(); + + if (m_pClientManager != nullptr) + { + delete m_pClientManager; + m_pClientManager = nullptr; + } + } + DD_ASSERT(result == Result::Success); + return result; + } + + // ===================================================================================================================== + // Destroys the listener core object and shuts down all communications + void ListenerCore::Destroy() + { + std::lock_guard lock(m_routerMutex); + + if (m_started) + { + if (m_pServer != nullptr) + { + pLogServer = nullptr; + m_pServer->Destroy(); + delete m_pServer; + m_pServer = nullptr; + } + + if (m_pMsgChannel != nullptr) + { + delete m_pMsgChannel; + m_pMsgChannel = nullptr; + } + + for (const auto &pTransport : m_managedTransports) + { + m_routerCore.RemoveTransport(pTransport); + } + m_managedTransports.clear(); + m_routerCore.Stop(); + m_started = false; + + if (m_pClientManager != nullptr) + { + delete m_pClientManager; + m_pClientManager = nullptr; + } + } + } + +#if !DD_VERSION_SUPPORTS(GPUOPEN_DISTRIBUTED_STATUS_FLAGS_VERSION) + // ===================================================================================================================== + // Sets the developer mode enabled client flag to the specified value + bool ListenerCore::SetDeveloperModeEnabled(bool developerModeEnabled) + { + bool result = false; + std::lock_guard lock(m_routerMutex); + if (m_pMsgChannel != nullptr) + { + result = (m_pMsgChannel->SetStatusFlag(developerModeEnabled) == Result::Success); + } + return result; + } + + // ===================================================================================================================== + // Returns the developer mode enabled client flag value + bool ListenerCore::GetDeveloperModeEnabled() + { + bool result = false; + std::lock_guard lock(m_routerMutex); + if (m_pMsgChannel != nullptr) + { + result = m_pMsgChannel->GetStatusFlag(); + } + return result; + } + + // ===================================================================================================================== + // Sets the halt on connect client flag to the specified value + bool ListenerCore::SetHaltOnConnect(bool haltOnConnect) + { + bool result = false; + std::lock_guard lock(m_routerMutex); + if (m_pMsgChannel != nullptr) + { + result = (m_pMsgChannel->SetStatusFlag(haltOnConnect) == Result::Success); + } + return result; + } + + // ===================================================================================================================== + // Returns the halt on connect client flag value + bool ListenerCore::GetHaltOnConnect() + { + bool result = false; + std::lock_guard lock(m_routerMutex); + if (m_pMsgChannel != nullptr) + { + result = m_pMsgChannel->GetStatusFlag(); + } + return result; + } +#endif +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/listenerCore.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/listenerCore.h new file mode 100644 index 000000000..8455bb9b0 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/listenerCore.h @@ -0,0 +1,146 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file listenerCore.h +* @brief Class declaration for ListenerCore +*********************************************************************************************************************** +*/ + +#pragma once + +#include "gpuopen.h" +#include +#include +#include "routerCore.h" +#include "msgChannel.h" +#include "ddPlatform.h" +#include "listenerServer.h" +#include "ddListenerURIService.h" + +namespace DevDriver +{ + // Flags for configuring the listener core's behavior + union ListenerConfigFlags + { + struct + { + // @Todo: Rename enableUWP support to enableKmd + uint32 enableUWP : 1; // Enables support for applications inside the Universal Windows Platform + // environment + uint32 enableServer : 1; // Enables the built-in listener server which allows the listener to + // communicate at an application protocol level with other clients on + // the bus + uint32 reserved : 30; // Reserved for future usage + }; + uint32 value; + }; + + // An address and port pair that the listener can listen for connections on + struct ListenerBindAddress + { + char hostAddress[kMaxStringLength]; // Network host address + uint32 port; // Network port + }; + + // Creation information for the listener core object + struct ListenerCreateInfo + { + char description[kMaxStringLength]; // Description string used to identify the listener on the message bus + ListenerConfigFlags flags; // Configuration flags + ListenerServerCreateInfo serverCreateInfo; // Creation information for the built in listener server + ListenerBindAddress* pAddressesToBind; // A list of addresses to lister for connections on + uint32 numAddresses; // The number of entries in pAddressesToBind + AllocCb allocCb; // An allocation callback that is used to manage memory allocations + }; + + // Logs a message to the console. + // Also logs a message into the logging protocol if the logging server is enabled on the listener. + void LogMessage(LogLevel logLevel, const char* format, ...); + + // Listener Core + // Designed to be a self contained class that manages all of the complexity of routing packets between clients on the message bus. + // Allows for limited configuration through the ListenerCreateInfo struct and otherwise behaves in a specific manner depending on + // the underlying platform. + class ListenerCore + { + public: + // Constructor + ListenerCore(); + + // Destructor + ~ListenerCore(); + + // Initialization + Result Initialize(ListenerCreateInfo& createInfo); + + // Destruction + void Destroy(); + +#if !DD_VERSION_SUPPORTS(GPUOPEN_DISTRIBUTED_STATUS_FLAGS_VERSION) + // Set the developer mode enabled client status flag + bool SetDeveloperModeEnabled(bool developerModeEnabled); + + // Get the developer mode enabled client status flag + bool GetDeveloperModeEnabled(); + + // Set the halt on connect client status flag + bool SetHaltOnConnect(bool haltOnConnect); + + // Get the halt on connect client status flag + bool GetHaltOnConnect(); +#endif + + // Constructs a vector of the currently connected clients and returns it + // This function has to acquire an internal lock so it should not be considered a "cheap" function + std::vector GetConnectedClientList(); + + // Returns a list of the currently managed transports. + const std::vector>& GetManagedTransports() const { return m_managedTransports; } + + // Returns the client manager pointer. + const IClientManager* GetClientManager() const { return m_pClientManager; } + + // Get the listener server associated with the listener core + // This will be null if the listener server was not enabled during initialization + ListenerServer* GetServer() { return m_pServer; } + const ListenerServer* GetServer() const { return m_pServer; } + + // Returns the ListenerCreateInfo struct that was used to initialize the listener core + const ListenerCreateInfo& GetCreateInfo() const { return m_createInfo; } + + private: + ListenerCreateInfo m_createInfo; // Creation information provided during initialization + RouterCore m_routerCore; // The underlying router core object + std::vector> m_managedTransports; // A vector of all transports that are managed by the listener + std::mutex m_routerMutex; // A mutex used to make access to the router thread safe + IClientManager* m_pClientManager; // Pointer to the current client manager object + bool m_started; // True if the listener has been started, false otherwise + // (Used for internal resource cleanup logic) + IMsgChannel* m_pMsgChannel; // Pointer to the underlying message channel object + ListenerServer* m_pServer; // Pointer to the current listener server object if it exists + ListenerURIService m_listenerURIService; // A URI service that provides listener specific information +}; + +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/listenerServer.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/listenerServer.cpp new file mode 100644 index 000000000..021acfe5d --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/listenerServer.cpp @@ -0,0 +1,183 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file listenerServer.cpp +* @brief Class definition for ListenerServer. +*********************************************************************************************************************** +*/ + +#include "listenerServer.h" +#include "../src/messageChannel.h" +#include "protocolServer.h" +#include "protocols/loggingServer.h" +#include "protocols/etwServer.h" + +namespace DevDriver +{ + ListenerServer::ListenerServer(const ListenerServerCreateInfo& createInfo, IMsgChannel *pMsgChannel) + : m_createInfo(createInfo) + , m_pMsgChannel(pMsgChannel) + { + } + + ListenerServer::~ListenerServer() + { + Destroy(); + } + + Result ListenerServer::Initialize() + { + Result result = Result::Error; + + if (m_pMsgChannel != nullptr) + { + result = m_pMsgChannel->Register(kInfiniteTimeout); + + if (result == Result::Success) + { + ClientMetadata filter = {}; + + m_pMsgChannel->Send(kBroadcastClientId, + Protocol::System, + static_cast(SystemProtocol::SystemMessage::ClientConnected), + filter, + 0, + nullptr); + + result = InitializeProtocols(); + + if (result != Result::Success) + { + // Unregister the message channel since we failed to initialize the protocols. + m_pMsgChannel->Unregister(); + } + } + + if (result != Result::Success) + { + // We failed to initialize so we need to destroy the message channel. + m_pMsgChannel = nullptr; + } + } + return result; + } + + void ListenerServer::Destroy() + { + if (m_pMsgChannel != nullptr) + { + Result result = m_pMsgChannel->Unregister(); + DD_ASSERT(result == Result::Success); + DD_UNUSED(result); + DestroyProtocols(); + + // We don't own the message channel so we set this to nullptr + m_pMsgChannel = nullptr; + } + } + + IMsgChannel* ListenerServer::GetMessageChannel() + { + return m_pMsgChannel; + } + + LoggingProtocol::LoggingServer* ListenerServer::GetLoggingServer() + { + return GetServer(); + } + + ETWProtocol::ETWServer * ListenerServer::GetEtwServer() + { + return GetServer(); + } + + Result ListenerServer::InitializeProtocols() + { + Result result = Result::Success; + + if (m_createInfo.enabledProtocols.logging) + { + result = RegisterProtocol(); + } + +#if defined(_WIN32) + if (m_createInfo.enabledProtocols.etw) + { + result = RegisterProtocol(); + } +#endif + + return result; + } + + void ListenerServer::DestroyProtocols() + { + if (m_createInfo.enabledProtocols.logging) + { + UnregisterProtocol(Protocol::Logging); + } + + if (m_createInfo.enabledProtocols.etw) + { + UnregisterProtocol(Protocol::ETW); + } + } + + Result ListenerServer::RegisterProtocol(Protocol protocol) + { + Result result = Result::Error; + if (m_pMsgChannel->GetProtocolServer(protocol) == nullptr) + { + switch (protocol) + { + case Protocol::Logging: + { + result = RegisterProtocol(); + break; + } + default: + { + // This shouldn't happen. Ever. + DD_UNREACHABLE(); + break; + } + } + } + return result; + } + + void ListenerServer::UnregisterProtocol(Protocol protocol) + { + IProtocolServer *pProtocolServer = m_pMsgChannel->GetProtocolServer(protocol); + if (pProtocolServer != nullptr) + { + const Result result = m_pMsgChannel->UnregisterProtocolServer(pProtocolServer); + DD_ASSERT(result == Result::Success); + DD_UNUSED(result); + delete pProtocolServer; + } + } + +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/listenerServer.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/listenerServer.h new file mode 100644 index 000000000..cf41918b3 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/listenerServer.h @@ -0,0 +1,95 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file listenerServer.h +* @brief Class declaration for ListenerServer. +*********************************************************************************************************************** +*/ + +#pragma once + +#include "gpuopen.h" +#include "msgChannel.h" +#include "msgTransport.h" +#include "protocols/systemProtocols.h" +#include "protocols/typemap.h" + +namespace DevDriver +{ + class IProtocolServer; + + struct ListenerServerCreateInfo + { + ProtocolFlags enabledProtocols; + }; + + class ListenerServer + { + public: + ListenerServer(const ListenerServerCreateInfo& createInfo, IMsgChannel *pMsgChannel); + ~ListenerServer(); + + Result Initialize(); + void Destroy(); + + IMsgChannel* GetMessageChannel(); + + LoggingProtocol::LoggingServer* GetLoggingServer(); + + ETWProtocol::ETWServer* GetEtwServer(); + + private: + Result InitializeProtocols(); + void DestroyProtocols(); + Result RegisterProtocol(Protocol protocol); + void UnregisterProtocol(Protocol protocol); + + ListenerServerCreateInfo m_createInfo; + IMsgChannel* m_pMsgChannel; + + template + Result RegisterProtocol(Args... args) + { + Result result = Result::Error; + using T = ProtocolServerType; + T* pProtocolServer = nullptr; + if (m_pMsgChannel->GetProtocolServer(protocol) == nullptr) + { + pProtocolServer = new T(m_pMsgChannel, args...); + result = m_pMsgChannel->RegisterProtocolServer(pProtocolServer); + } + return result; + }; + + template + ProtocolServerType* GetServer() + { + using T = ProtocolServerType; + return static_cast(m_pMsgChannel->GetProtocolServer(protocol)); + } + + }; + +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/routerCore.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/routerCore.cpp new file mode 100644 index 000000000..2adbf7491 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/routerCore.cpp @@ -0,0 +1,984 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file listenerCore.cpp +* @brief Class definition for RouterCore +*********************************************************************************************************************** +*/ + +#include "routerCore.h" +#include "../inc/ddPlatform.h" +#include +#include "protocols/systemProtocols.h" + +namespace DevDriver +{ + DD_STATIC_CONST ClientInfo kUnknownClient = + { + "Unknown", + "Unknown", + 0, + 0, + false + }; + + DD_STATIC_CONST ClientContext kNewClientContext = { + kUnknownClient, + {}, + 0, + false, + false + }; + + //@note: The clients mutex must always be owned during this function. + ClientContext* RouterCore::FindClientById(ClientId clientId) + { + ClientContext* pLocalClientInfo = nullptr; + auto search = m_clientMap.find(clientId); + if (search != m_clientMap.end()) + { + pLocalClientInfo = &search->second; + } + return pLocalClientInfo; + } + + //@note: The clients mutex must always be owned during this function. + ClientContext* RouterCore::FindExternalClientByConnection(const ConnectionInfo &connectionInfo) + { + const auto &find = m_transportMap.find(connectionInfo.handle); + if (find != m_transportMap.end()) + { + if (find->second.pTransport != nullptr && !find->second.pTransport->ForwardingConnection()) + { + for (auto& pair : find->second.clientMap) + { + if (pair.second.size == connectionInfo.size && + (memcmp(pair.second.data, connectionInfo.data, connectionInfo.size) == 0)) + { + auto findClient = m_clientMap.find(pair.first); + if (findClient != m_clientMap.end()) + { + return &findClient->second; + } + return nullptr; + } + } + } + } + return nullptr; + } + + //@note: The client and transport mutex must always be owned during this function. + void RouterCore::AddClient(const ClientId clientId, const ConnectionInfo &connectionInfo, const bool registeredClient) + { + DD_ASSERT(clientId != kBroadcastClientId); + + if (clientId != kBroadcastClientId) + { + const auto &find = m_transportMap.find(connectionInfo.handle); + if (find != m_transportMap.end() && find->second.pTransport != nullptr) + { + auto &transport = find->second; + ClientContext clientData(kNewClientContext); + clientData.clientInfo.clientId = clientId; + clientData.pingRetryCount = 0; + clientData.receivedPong = true; + clientData.connectionInfo = connectionInfo; + clientData.registeredClient = registeredClient; + + m_clientMap.emplace(clientId, clientData); + + transport.clientMap.emplace(clientId, connectionInfo); + + DD_PRINT(LogLevel::Info, "[RouterCore] Client %u connected via %s", clientId, transport.pTransport->GetTransportName()); + + } + } + } + + //@note: The client and transport mutex must always be owned during this function. + void RouterCore::RemoveClient(ClientId clientId) + { + const auto &find = m_clientMap.find(clientId); + if (find != m_clientMap.end()) + { + TransportHandle tHandle = find->second.connectionInfo.handle; + const auto &findTransport = m_transportMap.find(tHandle); + if (findTransport != m_transportMap.end() && findTransport->second.pTransport != nullptr) + { + auto &transport = findTransport->second; + if (transport.pTransport != nullptr) + { + transport.clientMap.erase(clientId); + DD_PRINT(LogLevel::Info, "[RouterCore] Client %u disconnected from %s", clientId, transport.pTransport->GetTransportName()); + } + } + + if (find->second.registeredClient) + { + m_pClientManager->UnregisterClient(find->first); + + MessageBuffer messageBuffer = {}; + messageBuffer.header.dstClientId = kBroadcastClientId; + messageBuffer.header.srcClientId = clientId; + messageBuffer.header.protocolId = Protocol::System; + messageBuffer.header.messageId = static_cast(SystemProtocol::SystemMessage::ClientDisconnected); + messageBuffer.header.payloadSize = 0; + SendBroadcastMessage(messageBuffer, nullptr); + } + m_clientMap.erase(find); + } + } + + void RouterCore::SendBroadcastMessage(const MessageBuffer &message, const std::shared_ptr &pSourceTransport) + { + const ClientId &srcClientId = message.header.srcClientId; + + ClientId lastFailedClient = kBroadcastClientId; + + for (auto& pair : m_transportMap) + { + TransportContext &context = pair.second; + if (context.pTransport != nullptr) + { + std::shared_ptr &pTransport = context.pTransport; + if (pTransport->ForwardingConnection()) + { + if (pTransport != pSourceTransport) + { + pTransport->TransmitBroadcastMessage(message); + } + } + else if (context.clientMap.size() > 0) + { + for (const auto &clientPair : context.clientMap) + { + if (clientPair.first != srcClientId && + pTransport->TransmitMessage(clientPair.second, message) == Result::Error) + { + lastFailedClient = clientPair.first; + } + } + } + } + } + + // this is technically recursive - every time a write fails, it will call SendBroadcastMessage to announce the client disconnect + // which will then traverse the list of clients and trigger additional failures. + if (lastFailedClient != kBroadcastClientId) + { + RemoveClient(lastFailedClient); + } + + } + + void RouterCore::ProcessRouterMessage(const MessageContext &messageContext) + { + const auto &messageHeader = messageContext.message.header; + const auto &message = messageContext.message; + + const auto &srcClientId = messageHeader.srcClientId; + + const auto &pTransport = TransportForTransportHandle(messageContext.connectionInfo.handle); + + if (pTransport != nullptr) + { + // Process system messages + if (messageHeader.protocolId == Protocol::System) + { + using namespace DevDriver::SystemProtocol; + + DD_ASSERT((messageHeader.dstClientId == m_clientId) || (messageHeader.dstClientId == kBroadcastClientId)); + + bool queryClientInfo = false; + + std::unique_lock lock(m_clientMutex); + + ClientContext* pSrcClientInfo = FindClientById(srcClientId); + + if ((pSrcClientInfo == nullptr) & + (static_cast(messageHeader.messageId) != SystemMessage::ClientDisconnected)) + { + AddClient(srcClientId, messageContext.connectionInfo, false); + + queryClientInfo = true; + } + + switch (static_cast(messageHeader.messageId)) + { + case SystemMessage::ClientConnected: + { + if (pSrcClientInfo != nullptr && !pSrcClientInfo->clientInfo.hasBeenIdentified) + { + queryClientInfo = true; + } + break; + } + case SystemMessage::ClientDisconnected: + { + if (pSrcClientInfo != nullptr) + { + RemoveClient(srcClientId); + } + break; + } + case SystemMessage::Pong: + { + if (pSrcClientInfo != nullptr) + { + // Update the last response time if we already know about this client. + pSrcClientInfo->receivedPong = true; + if (!pSrcClientInfo->clientInfo.hasBeenIdentified) + { + queryClientInfo = true; + } + } + break; + } + case SystemMessage::ClientInfo: + { + + // this should literally be impossible. + DD_ASSERT(pSrcClientInfo != nullptr); + + { + const ClientInfoStruct* DD_RESTRICT pPayload = reinterpret_cast(&message.payload[0]); + Platform::Strncpy(pSrcClientInfo->clientInfo.clientName, pPayload->clientName, sizeof(pSrcClientInfo->clientInfo.clientName)); + Platform::Strncpy(pSrcClientInfo->clientInfo.clientDescription, pPayload->clientDescription, sizeof(pSrcClientInfo->clientInfo.clientDescription)); + pSrcClientInfo->clientInfo.clientPid = pPayload->processId; + } + + pSrcClientInfo->pingRetryCount = 0; + pSrcClientInfo->receivedPong = true; + + pSrcClientInfo->clientInfo.hasBeenIdentified = true; + queryClientInfo = false; + break; + } + default: + break; + } + + lock.unlock(); + + if (queryClientInfo) + { + MessageBuffer messageBuffer = {}; + messageBuffer.header.messageId = static_cast(SystemMessage::QueryClientInfo); + messageBuffer.header.payloadSize = 0; + + messageBuffer.header.srcClientId = m_clientId; + messageBuffer.header.dstClientId = srcClientId; + messageBuffer.header.protocolId = Protocol::System; + if (pTransport->TransmitMessage(messageContext.connectionInfo, messageBuffer) == Result::Error) + { + RemoveClient(srcClientId); + } + } + } + } + } + + ///////////////////////////// + // Periodically sends client discovery packets into the network to keep the local client list up to date. + void RouterCore::UpdateClients() + { + // Check if the update interval has been reached. + uint64 currentTimeInMs = Platform::GetCurrentTimeInMs(); + if ((currentTimeInMs - kClientDiscoveryIntervalInMs) >= m_lastClientPingTimeInMs) + { + std::lock_guard clientLock(m_clientMutex); + + for (auto it = m_clientMap.begin(); it != m_clientMap.end(); ) + { + const ClientId &clientId = it->first; + const TransportHandle &tHandle = it->second.connectionInfo.handle; + if (it->second.receivedPong) + { + it->second.pingRetryCount = 0; + it->second.receivedPong = false; + } + else + { + it->second.pingRetryCount += 1; + } + + // Remove the local client from our list if they've timed out. + if (it->second.pingRetryCount > kClientTimeoutCount) + { + std::lock_guard transportLock(m_transportMutex); + const auto &find = m_transportMap.find(tHandle); + if (find != m_transportMap.end()) + { + auto &transport = find->second; + if (transport.pTransport != nullptr) + { + if (transport.clientMap.erase(clientId) > 0) + { + DD_PRINT(LogLevel::Info, + "[RouterCore] Client %u timed out from %s", + clientId, + transport.pTransport->GetTransportName()); + } + } + } + if (it->second.registeredClient) + { + m_pClientManager->UnregisterClient(clientId); + MessageBuffer messageBuffer = {}; + messageBuffer.header.dstClientId = kBroadcastClientId; + messageBuffer.header.srcClientId = clientId; + messageBuffer.header.protocolId = Protocol::System; + messageBuffer.header.messageId = static_cast(SystemProtocol::SystemMessage::ClientDisconnected); + messageBuffer.header.payloadSize = 0; + SendBroadcastMessage(messageBuffer, nullptr); + } + it = m_clientMap.erase(it); + } + else + { + ++it; + } + } + + m_lastClientPingTimeInMs = currentTimeInMs; + + // Broadcast a client discovery request into the local network. + MessageBuffer messageBuffer = {}; + + messageBuffer.header.srcClientId = m_clientId; + messageBuffer.header.dstClientId = kBroadcastClientId; + messageBuffer.header.protocolId = Protocol::System; + messageBuffer.header.messageId = static_cast(SystemProtocol::SystemMessage::Ping); + messageBuffer.header.sessionId = kInvalidSessionId; + messageBuffer.header.sequence = 0; + messageBuffer.header.payloadSize = 0; + + std::lock_guard transportLock(m_transportMutex); + SendBroadcastMessage(messageBuffer, nullptr); + // Update the last client discovery time. + } + } + + void RouterCore::ProcessClientManagementMessage(const MessageContext &messageContext) + { + using namespace DevDriver::ClientManagementProtocol; + const auto &message = messageContext.message; + const auto &messageHeader = message.header; + + std::lock_guard clientLock(m_clientMutex); + std::lock_guard transportLock(m_transportMutex); + + const auto &find = m_transportMap.find(messageContext.connectionInfo.handle); + if (find != m_transportMap.end() && find->second.pTransport != nullptr) + { + const auto &pTransport = find->second.pTransport; + + // if both the source and destination are broadcast, we treat these as special cases for client registration + // detect messages that are the wrong versions + if (IsOutOfBandMessage(message) & !IsValidOutOfBandMessage(message)) + { + MessageBuffer messageBuffer = kOutOfBandMessage; + // this assumes that these are valid for the protocol + messageBuffer.header.messageId = static_cast(ManagementMessage::ConnectResponse); + messageBuffer.header.payloadSize = sizeof(ConnectResponsePayload); + // we want to overwrite the protocol id to the original protocol id, that way the client can properly recognize it + messageBuffer.header.protocolId = messageHeader.protocolId; + + { + ConnectResponsePayload* DD_RESTRICT pPayload = reinterpret_cast(&messageBuffer.payload[0]); + pPayload->clientId = kBroadcastClientId; + pPayload->result = Result::VersionMismatch; + } + + // Send the response and return the result. + do {} while (pTransport->TransmitMessage(messageContext.connectionInfo, messageBuffer) == Result::NotReady); + + return; + } else if (IsOutOfBandMessage(message) & IsValidOutOfBandMessage(message) & + (static_cast(messageHeader.messageId) == ManagementMessage::KeepAlive)) + { + // keepalive packet, discard + DD_PRINT(LogLevel::Debug, "Received keep alive packet seq %u", messageHeader.sessionId); + MessageBuffer messageBuffer = kOutOfBandMessage; + // this assumes that these are valid for the protocol + messageBuffer.header.messageId = static_cast(ManagementMessage::KeepAlive); + messageBuffer.header.payloadSize = 0; + messageBuffer.header.sessionId = messageHeader.sessionId; + do {} while (pTransport->TransmitMessage(messageContext.connectionInfo, messageBuffer) == Result::NotReady); + return; + } + + const auto &srcClientId = messageHeader.srcClientId; + + switch (static_cast(messageHeader.messageId)) + { + case ManagementMessage::ConnectRequest: + { + Result result = Result::VersionMismatch; + ClientId externalClientId = kBroadcastClientId; + + if (messageHeader.payloadSize == sizeof(ConnectRequestPayload)) + { + result = Result::Error; + ClientContext* pExternalClientInfo = FindExternalClientByConnection(messageContext.connectionInfo); + + // Accept the client if it's a new client. + if (pExternalClientInfo == nullptr) + { +#if DD_VERSION_SUPPORTS(GPUOPEN_DEPRECATE_LEGACY_KMD_VERSION) + result = m_pClientManager->RegisterClient(&externalClientId); +#else + { + const ConnectRequestPayload *DD_RESTRICT pPayload = reinterpret_cast(&message.payload[0]); + result = m_pClientManager->RegisterClient(pPayload->componentType, pPayload->initialClientFlags, &externalClientId); + } +#endif + if (result == Result::Success) + { + DD_ASSERT(externalClientId != kBroadcastClientId); + AddClient(externalClientId, messageContext.connectionInfo, true); + MessageBuffer messageBuffer = {}; + messageBuffer.header.dstClientId = kBroadcastClientId; + messageBuffer.header.srcClientId = externalClientId; + messageBuffer.header.protocolId = Protocol::System; + messageBuffer.header.messageId = static_cast(SystemProtocol::SystemMessage::ClientConnected); + messageBuffer.header.payloadSize = 0; + SendBroadcastMessage(messageBuffer, nullptr); + } + } + else + { + result = Result::Success; + externalClientId = pExternalClientInfo->clientInfo.clientId; + DD_ASSERT(externalClientId != kBroadcastClientId); + } + + } + + MessageBuffer messageBuffer = kOutOfBandMessage; + // this assumes that these are valid for the protocol + messageBuffer.header.messageId = static_cast(ManagementMessage::ConnectResponse); + messageBuffer.header.payloadSize = sizeof(ConnectResponsePayload); + // we want to overwrite the protocol id to the original protocol id, that way the client can properly recognize it + messageBuffer.header.protocolId = messageHeader.protocolId; + + { + ConnectResponsePayload *DD_RESTRICT pPayload = reinterpret_cast(&messageBuffer.payload[0]); + pPayload->clientId = externalClientId; + pPayload->result = result; + } + + // Send the response and return the result. + if (pTransport->TransmitMessage(messageContext.connectionInfo, messageBuffer) == Result::Error) + { + if (externalClientId != kBroadcastClientId) + RemoveClient(externalClientId); + } + } + break; + case ManagementMessage::DisconnectNotification: + { + // look up client context to see if the client transmitting the message is managed by the listener + ClientContext* pExternalClientInfo = FindExternalClientByConnection(messageContext.connectionInfo); + + // make sure the client transmitting is the same as the client we are expecting + if (pExternalClientInfo != NULL && srcClientId == pExternalClientInfo->clientInfo.clientId) + { + MessageBuffer messageBuffer = {}; + messageBuffer.header.srcClientId = m_clientId; + messageBuffer.header.dstClientId = srcClientId; + messageBuffer.header.protocolId = messageHeader.protocolId; + messageBuffer.header.messageId = static_cast(ManagementMessage::DisconnectResponse); + messageBuffer.header.payloadSize = 0; + + // notify the client the connection is terminated + pTransport->TransmitMessage(messageContext.connectionInfo, messageBuffer); + + // remove the client since it was valid + RemoveClient(srcClientId); + } + } + break; + case ManagementMessage::SetClientFlags: + { + // look up client context to see if the client transmitting the message is managed by the listener + ClientContext* pExternalClientInfo = FindExternalClientByConnection(messageContext.connectionInfo); + + // make sure the client transmitting is the same as the client we are expecting + if (pExternalClientInfo != NULL && srcClientId == pExternalClientInfo->clientInfo.clientId) + { + // set up the response message buffer + MessageBuffer messageBuffer = {}; + messageBuffer.header.srcClientId = m_clientId; + messageBuffer.header.dstClientId = srcClientId; + messageBuffer.header.protocolId = messageHeader.protocolId; + messageBuffer.header.messageId = static_cast(ManagementMessage::SetClientFlagsResponse); + messageBuffer.header.payloadSize = sizeof(SetClientFlagsResponsePayload); + { + + SetClientFlagsResponsePayload* DD_RESTRICT pResponse = reinterpret_cast(&messageBuffer.payload[0]); +#if DD_VERSION_SUPPORTS(GPUOPEN_DISTRIBUTED_STATUS_FLAGS_VERSION) + // for backwards compatibility we inform the client that the request failed + pResponse->result = Result::Error; +#else + const SetClientFlagsPayload* DD_RESTRICT pPayload = reinterpret_cast(&message.payload[0]); + // call UpdateClientStatus and save result into reponse buffer + pResponse->result = m_pClientManager->UpdateClientStatus(srcClientId, pPayload->flags); +#endif + } + + // Send the response and return the result. + Result transmitResult; + do + { + transmitResult = pTransport->TransmitMessage(messageContext.connectionInfo, messageBuffer); + } while (transmitResult == Result::NotReady); + + // if we failed to transmit to the client, we need to remove it + if (transmitResult == Result::Error) + { + RemoveClient(srcClientId); + } + } + } + break; + case ManagementMessage::QueryStatus: + { + MessageBuffer messageBuffer = kOutOfBandMessage; + // this assumes that these are valid for the protocol + messageBuffer.header.messageId = static_cast(ManagementMessage::QueryStatusResponse); + messageBuffer.header.payloadSize = sizeof(QueryStatusResponsePayload); + // we want to overwrite the protocol id to the original protocol id, that way the client can properly recognize it + messageBuffer.header.protocolId = messageHeader.protocolId; + + { + QueryStatusResponsePayload* DD_RESTRICT pResponse = reinterpret_cast(&messageBuffer.payload[0]); +#if DD_VERSION_SUPPORTS(GPUOPEN_DISTRIBUTED_STATUS_FLAGS_VERSION) + // for backwards compatibility we inform clients that developer mode is enabled + return success + pResponse->flags = static_cast(ClientStatusFlags::DeveloperModeEnabled); + pResponse->result = Result::Success; +#else + pResponse->result = m_pClientManager->QueryStatus(&pResponse->flags); +#endif + } + Result transmitResult; + + do + { + transmitResult = pTransport->TransmitMessage(messageContext.connectionInfo, messageBuffer); + } while (transmitResult == Result::NotReady); + if (transmitResult == Result::Error) + { + RemoveClient(srcClientId); + } + } + break; + default: + break; + } + } + //clientLock.unlock();} + } + + bool RouterCore::IsRoutableMessage(const MessageContext &recvMsgContext) + { + + const ClientId &dstClientId = recvMsgContext.message.header.dstClientId; + const ClientId &srcClientId = recvMsgContext.message.header.srcClientId; + + bool isClientManagement = ((recvMsgContext.message.header.protocolId == Protocol::ClientManagement) + | ClientManagementProtocol::IsOutOfBandMessage(recvMsgContext.message)); + + if (isClientManagement) + { + RouteInternalMessage(recvMsgContext); + } + else if (srcClientId != kBroadcastClientId) + { + if ((recvMsgContext.message.header.protocolId == Protocol::System) & + ((dstClientId == kBroadcastClientId) | (dstClientId == m_clientId))) + { + // enqueue for the client management thread + RouteInternalMessage(recvMsgContext); + } + return true; + } + return false; + } + + bool RouterCore::ConnectionInfoForClientId(ClientId clientId, ConnectionInfo *pConnectionInfo) + { + if (clientId == kBroadcastClientId) + return false; + std::lock_guard clientLock(m_clientMutex); + ClientContext* pClientInfo = FindClientById(clientId); + if (pClientInfo != nullptr) + { + *pConnectionInfo = pClientInfo->connectionInfo; + return true; + } + return false; + } + + std::shared_ptr RouterCore::TransportForTransportHandle(TransportHandle handle) + { + if (handle != 0) + { + std::lock_guard transportLock(m_transportMutex); + const auto &find = m_transportMap.find(handle); + if (find != m_transportMap.end()) + { + return find->second.pTransport; + } + } + return std::shared_ptr(); + } + + void RouterCore::RouteBroadcastMessage(const MessageContext& msgContext) + { + std::lock_guard clientLock(m_clientMutex); + std::lock_guard transportLock(m_transportMutex); + + std::shared_ptr pSourceTransport; + const auto &find = m_transportMap.find(msgContext.connectionInfo.handle); + if (find != m_transportMap.end()) + { + pSourceTransport = find->second.pTransport; + } + SendBroadcastMessage(msgContext.message, pSourceTransport); + } + + void RouterCore::RouteInternalMessage(const MessageContext & recvMsgContext) + { + // Process the broadcast message locally before rebroadcasting it. + std::lock_guard lock(m_clientThread.mutex); + m_clientThread.queue.emplace_back(recvMsgContext); + m_clientThread.signal.notify_one(); + } + + void RouterCore::RouterThreadFunc(ProcessingQueue &queueState) + { + std::deque messageBuffer; + const auto waitTime = std::chrono::milliseconds((int64)kThreadWaitTimeoutInMs); + + while (queueState.active) + { + bool swapped = false; + + std::unique_lock lock(queueState.mutex); + if (queueState.signal.wait_for(lock,waitTime, [&] { return !queueState.queue.empty(); })) + { + messageBuffer.swap(queueState.queue); + swapped = true; + } + + lock.unlock(); + + if (swapped) + { + for (const auto& messageContext : messageBuffer) + { + bool isClientManagement = ((messageContext.message.header.protocolId == Protocol::ClientManagement) + | ClientManagementProtocol::IsOutOfBandMessage(messageContext.message)); + + if (isClientManagement) + { + ProcessClientManagementMessage(messageContext); + } + else + { + ProcessRouterMessage(messageContext); + } + } + messageBuffer.clear(); + } + UpdateClients(); + } + } + + std::vector RouterCore::GetConnectedClientList() + { + std::vector result = std::vector(); + std::lock_guard lock(m_clientMutex); + + result.reserve(m_clientMap.size()); + for (const auto& pair : m_clientMap) + { + if (pair.first != m_clientId) + { + result.emplace_back(pair.second.clientInfo); + } + } + + //clientLock.unlock(); + return result; + } + + RouterCore::RouterCore() : + m_pClientManager(nullptr), + m_lastTransportId(0), + m_lastClientPingTimeInMs(0), + m_clientThread(), + m_clientInfoResponse() + { + + } + + RouterCore::~RouterCore() + { + if (m_pClientManager != nullptr) + Stop(); + } + + Result RouterCore::Start(RouterStartInfo &startInfo) + { + Result result = Result::Error; + + // only do this if we have both a client manager and something to talk to + std::lock_guard transportLock(m_transportMutex); + if ((m_pClientManager != nullptr) & (m_transportMap.size() > 0)) + { + // Initialize the last discovery time to the current time - some offset. + m_lastClientPingTimeInMs = 0; + + m_clientThread.active = true; + m_clientThread.thread = std::thread(&DevDriver::RouterCore::RouterThreadFunc, this, std::ref(m_clientThread)); + + DD_ASSERT(m_clientThread.thread.joinable()); + + DD_PRINT(LogLevel::Verbose, "[RouterCore] Started client management thread!"); + + // initialize the default query client info response + ClientInfoStruct* DD_RESTRICT pPayload = reinterpret_cast(&m_clientInfoResponse.payload[0]); + memset(pPayload, 0, sizeof(ClientInfoStruct)); + m_clientInfoResponse.header.messageId = static_cast(SystemProtocol::SystemMessage::ClientInfo); + m_clientInfoResponse.header.payloadSize = sizeof(ClientInfoStruct); + m_clientInfoResponse.header.protocolId = Protocol::System; + Platform::Strncpy(pPayload->clientDescription, startInfo.description, sizeof(pPayload->clientDescription)); + Platform::GetProcessName(&pPayload->clientName[0], sizeof(pPayload->clientName)); + pPayload->processId = Platform::GetProcessId(); + + result = Result::Success; + } + return result; + } + + Result RouterCore::SetClientManager(IClientManager *pClientManager) + { + Result result = Result::Error; + if (m_pClientManager == nullptr) + { + result = pClientManager->RegisterHost(&m_clientId); + if ((result == Result::Success) & (m_clientId != kBroadcastClientId)) + { + m_pClientManager = pClientManager; + + DD_PRINT(LogLevel::Verbose, "[RouterCore] Registered client manager: %s", pClientManager->GetClientManagerName()); + + const std::shared_ptr &pHostTransport = m_pClientManager->GetHostTransport(); + if (pHostTransport != nullptr) + { + result = RegisterTransport(pHostTransport); + } + } + } + return result; + } + + Result RouterCore::RegisterTransport(const std::shared_ptr &pTransport) + { + std::lock_guard transportLock(m_transportMutex); + TransportHandle handle = ++m_lastTransportId; + Result result = pTransport->Enable(this, handle); + + if (result == DevDriver::Result::Success) + { + DD_PRINT(LogLevel::Verbose, "[RouterCore] Registered transport: %s", pTransport->GetTransportName()); + TransportContext newContext; + newContext.pTransport = pTransport; + m_transportMap[handle] = newContext; + } + + return result; + } + + Result RouterCore::RemoveTransport(const std::shared_ptr &pTransport) + { + DD_ASSERT(pTransport != nullptr); + + Result result = Result::Error; + + TransportHandle tHandle = pTransport->GetHandle(); + std::unique_lock transportLock(m_transportMutex); + + const auto &find = m_transportMap.find(tHandle); + if (find != m_transportMap.end()) + { + const auto clientMap = find->second.clientMap; + for (const auto &pair : clientMap) + { + RemoveClient(pair.first); + } + m_transportMap.erase(tHandle); + DD_PRINT(LogLevel::Verbose, "[RouterCore] Removing transport: %s", pTransport->GetTransportName()); + result = Result::Success; + } + + transportLock.unlock(); + + if (result == Result::Success) + { + pTransport->Disable(); + } + return result; + } + + void RouterCore::Stop() + { + DD_ASSERT(m_pClientManager != nullptr); + + DD_PRINT(LogLevel::Verbose, "[RouterCore] Shutting down transport threads..."); + + std::unique_lock transportLock(m_transportMutex); + std::unordered_set> transports; + + for (auto &it : m_transportMap) + { + if (it.second.pTransport != nullptr) + transports.emplace(it.second.pTransport); + } + transportLock.unlock(); + + for (auto &pTransport : transports) + { + RemoveTransport(pTransport); + } + + DD_PRINT(LogLevel::Verbose, "[RouterCore] Shutting down client management thread..."); + + if (m_clientThread.active) + { + m_clientThread.active = false; + + if (m_clientThread.thread.joinable()) + m_clientThread.thread.join(); + + DD_PRINT(LogLevel::Verbose, "[RouterCore] Client management thread successfully shut down!"); + } + + if (m_pClientManager != nullptr) + { + DevDriver::Result result = m_pClientManager->UnregisterHost(); + DD_ASSERT(result == DevDriver::Result::Success); + DD_UNUSED(result); + m_pClientManager = nullptr; + } + } + + Result RoutingCache::RouteMessage(const MessageContext & messageContext) + { + Result result = Result::Unavailable; + const ClientId &dstClientId = messageContext.message.header.dstClientId; + DD_ASSERT(messageContext.connectionInfo.handle != 0); + if (m_pRouter->IsRoutableMessage(messageContext)) + { + // If it's a broadcast message, we punt this over to the RouterCore since it has the current list of + // all transports. This needs to be updated sometime to improve performance and minimize locking, but + // for the time being this is acceptable. + if (dstClientId == kBroadcastClientId) + { + m_pRouter->RouteBroadcastMessage(messageContext); + result = Result::Success; + } + else + { + // If it is a directed message, we check to see if it's the same as the last client we talked to. That + // lets us skip the overhead of looking up the connection info for every packet during burst traffic + // situations + if (m_currentClientId != dstClientId) + { + // If it isn't, we first invalidate previous state + m_pCurrentClientContext = nullptr; + m_currentClientId = dstClientId; + + // First things first, we perform a lookup in the cache. + const auto find = m_routingCache.find(dstClientId); + if (find != m_routingCache.end()) + { + // If it existed in the cache then we can guarantee that there was - at one point - a valid + // transport associated with it. + m_pCurrentClientContext = &find->second; + } + else + { + // If it doesn't exist in the cache we need to look up both the connection info and the + // transport information from the main router. + CacheClientContext newClientContext = {}; + ConnectionInfo& connectionInfo = newClientContext.connectionInfo; + std::shared_ptr& pTransport = newClientContext.pTransport; + + // First lookup the client ID to see if the router knows about it + if (m_pRouter->ConnectionInfoForClientId(dstClientId, &connectionInfo)) + { + DD_ASSERT(connectionInfo.handle != 0); + // Then look up the transport associated with its transport handle. This lookup should + // never fail. If it fails, very bad things have happened and we are in an undefined state. + pTransport = m_pRouter->TransportForTransportHandle(connectionInfo.handle); + DD_ASSERT(pTransport != nullptr); + + // Place the client context inside the routing cache and set the pointer to it. + const auto res = m_routingCache.emplace(dstClientId, newClientContext); + m_pCurrentClientContext = &res.first->second; + } + } + } + + // If we have a valid client context then we send the message + if (m_pCurrentClientContext != nullptr) + { + const ConnectionInfo& connectionInfo = m_pCurrentClientContext->connectionInfo; + const std::shared_ptr& pTransport = m_pCurrentClientContext->pTransport; + + result = pTransport->TransmitMessage(connectionInfo, messageContext.message); + + // If the transport failed (not timed out), erase the client from the routing cache, null out + // the current state, and remove the client from the Router. + if (result == Result::Error) + { + m_routingCache.erase(dstClientId); + m_pCurrentClientContext = nullptr; + m_currentClientId = kBroadcastClientId; + + std::lock_guard clientLock(m_pRouter->m_clientMutex); + std::lock_guard transportLock(m_pRouter->m_transportMutex); + m_pRouter->RemoveClient(dstClientId); + } + } + } + } + return result; + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/routerCore.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/routerCore.h new file mode 100644 index 000000000..e62a9d331 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/routerCore.h @@ -0,0 +1,171 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file listenerCore.h +* @brief Class declaration for RouterCore +*********************************************************************************************************************** +*/ + +#pragma once + +#include "gpuopen.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "transportThread.h" + +#include "transports/abstractListenerTransport.h" +#include "clientmanagers/abstractClientManager.h" + +namespace DevDriver +{ + + struct ClientInfo + { + char clientName[kMaxStringLength]; + char clientDescription[kMaxStringLength]; + ProcessId clientPid; + ClientId clientId; + bool hasBeenIdentified; + }; + + struct ClientContext + { + ClientInfo clientInfo; + ConnectionInfo connectionInfo; + uint32 pingRetryCount; + bool receivedPong; + bool registeredClient; + }; + + struct TransportContext + { + std::shared_ptr pTransport; + std::unordered_map clientMap; + }; + + struct MessageContext + { + MessageBuffer message; + ConnectionInfo connectionInfo; + }; + + struct ProcessingQueue + { + std::deque queue; + std::condition_variable signal; + std::mutex mutex; + std::thread thread; + volatile bool active = 0; + }; + + struct RouterStartInfo + { + char description[kMaxStringLength]; + }; + + class RoutingCache + { + public: + explicit RoutingCache(RouterCore *pRouter) : m_pRouter(pRouter) {}; + ~RoutingCache() {}; + + Result RouteMessage(const MessageContext &messageContext); + private: + struct CacheClientContext + { + ConnectionInfo connectionInfo; + std::shared_ptr pTransport; + }; + + RouterCore* m_pRouter; + std::unordered_map m_routingCache; + + ClientId m_currentClientId = kBroadcastClientId; + CacheClientContext* m_pCurrentClientContext = nullptr; + }; + + class RouterCore + { + friend RoutingCache; + public: + RouterCore(); + ~RouterCore(); + + Result Start(RouterStartInfo &startInfo); + + Result SetClientManager(IClientManager *pClientManager); + Result RegisterTransport(const std::shared_ptr &pTransport); + Result RemoveTransport(const std::shared_ptr &pTransport); + + void Stop(); + + std::vector GetConnectedClientList(); + + private: + DD_STATIC_CONST uint32 kClientDiscoveryIntervalInMs = 3000; + DD_STATIC_CONST uint32 kClientTimeoutCount = 3; + DD_STATIC_CONST uint32 kThreadWaitTimeoutInMs = 250; + + std::mutex m_clientMutex; + std::unordered_map m_clientMap; + std::mutex m_transportMutex; + std::unordered_map m_transportMap; + + IClientManager* m_pClientManager; + TransportHandle m_lastTransportId; + ClientId m_clientId; + uint64 m_lastClientPingTimeInMs; + ProcessingQueue m_clientThread; + MessageBuffer m_clientInfoResponse; + + void RouterThreadFunc(ProcessingQueue &pQueueState); + void UpdateClients(); + void ProcessRouterMessage(const MessageContext &messageContext); + + ClientContext* FindClientById(ClientId clientId); + ClientContext* FindExternalClientByConnection(const ConnectionInfo & connectionInfo); + + void AddClient(const ClientId clientId, const ConnectionInfo &connectionInfo, const bool registeredClient); + void RemoveClient(ClientId clientId); + + void SendBroadcastMessage(const MessageBuffer &message, const std::shared_ptr &pTransport); + void ProcessClientManagementMessage(const MessageContext &messageContext); + + // methods for interfacing with RoutingCache + bool ConnectionInfoForClientId(ClientId clientId, ConnectionInfo *pConnectionInfo); + std::shared_ptr TransportForTransportHandle(TransportHandle handle); + void RouteBroadcastMessage(const MessageContext& msgContext); + void RouteInternalMessage(const MessageContext& recvMsgContext); + bool IsRoutableMessage(const MessageContext& recvMsgContext); + }; +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/transportThread.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/transportThread.cpp new file mode 100644 index 000000000..78bf88342 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/transportThread.cpp @@ -0,0 +1,104 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file listenerCore.cpp +* @brief Class definition for RouterCore +*********************************************************************************************************************** +*/ + +#include "transportThread.h" +#include "routerCore.h" +#include "../inc/ddPlatform.h" + +namespace DevDriver +{ + void TransportThread::ReceiveThreadFunc(RouterCore *pRouter, IListenerTransport *pTransport) + { + if ((pRouter != nullptr) & (pTransport != nullptr)) + { + RoutingCache cache(pRouter); + MessageContext recvMsgContext = {}; + std::deque recvQueue; + std::deque retryQueue; + + while (m_active) + { + size_t firstNewMessageIndex = recvQueue.size(); + // Check for new local messages. + Result readResult = pTransport->ReceiveMessage(recvMsgContext.connectionInfo, recvMsgContext.message, kReceiveDelayInMs); + if (readResult == Result::Success) + { + do + { + recvQueue.emplace_back(recvMsgContext); + readResult = pTransport->ReceiveMessage(recvMsgContext.connectionInfo, recvMsgContext.message, kNoWait); + } while (readResult == Result::Success); + } + + size_t messageNumber = 0; + for (const auto &message : recvQueue) + { + messageNumber++; + // only requeue messages if it's the first time we've tried to send them + if ((cache.RouteMessage(message) == Result::NotReady) & (messageNumber > firstNewMessageIndex)) + { + retryQueue.emplace_back(message); + } + } + recvQueue.clear(); + recvQueue.swap(retryQueue); + } + } + } + + void TransportThread::Start(RouterCore *pRouter, IListenerTransport *pTransport) + { + DD_ASSERT(m_active == false); + m_active = true; + m_thread = std::thread(&DevDriver::TransportThread::ReceiveThreadFunc, this, pRouter, pTransport); + DD_ASSERT(m_thread.joinable()); + } + + void TransportThread::Stop() + { + if (m_active) + { + m_active = false; + if (m_thread.joinable()) + m_thread.join(); + } + } + + TransportThread::TransportThread() : + m_active(false) + { + } + + TransportThread::~TransportThread() + { + if (m_active) + Stop(); + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/transportThread.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/transportThread.h new file mode 100644 index 000000000..509dcafb4 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/transportThread.h @@ -0,0 +1,55 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file listenerCore.h +* @brief Class declaration for RouterCore +*********************************************************************************************************************** +*/ + +#pragma once + +#include "gpuopen.h" + +#include "transports/abstractListenerTransport.h" + +#include + +namespace DevDriver +{ + class TransportThread + { + public: + TransportThread(); + ~TransportThread(); + + void Start(class RouterCore *pListener, IListenerTransport *pTransport); + void Stop(); + private: + void ReceiveThreadFunc(RouterCore *pRouter, IListenerTransport *pTransport); + DD_STATIC_CONST uint32 kReceiveDelayInMs = 25; + std::thread m_thread; + volatile bool m_active; + }; +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/transports/abstractListenerTransport.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/transports/abstractListenerTransport.h new file mode 100644 index 000000000..e6d42af83 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/transports/abstractListenerTransport.h @@ -0,0 +1,67 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file abstractListenerTransport.h +* @brief Class declaration for IListenerTransport +*********************************************************************************************************************** +*/ + +#pragma once + +#include "gpuopen.h" + +namespace DevDriver +{ + const uint32 kConnectionInfoDataSize = 128; + typedef uint32 TransportHandle; + + struct ConnectionInfo + { + char data[kConnectionInfoDataSize]; + size_t size; + TransportHandle handle; + }; + + class RouterCore; + + class IListenerTransport + { + public: + virtual ~IListenerTransport() {} + + virtual Result Enable(RouterCore* pRouter, TransportHandle handle) = 0; + virtual Result ReceiveMessage(ConnectionInfo &connectionInfo, MessageBuffer &message, uint32 timeoutInMs) = 0; + virtual Result TransmitMessage(const ConnectionInfo &connectionInfo, const MessageBuffer &message) = 0; + virtual Result TransmitBroadcastMessage(const MessageBuffer &message) = 0; + virtual Result Disable() = 0; + + virtual TransportHandle GetHandle() = 0; + virtual bool ForwardingConnection() = 0; + virtual const char* GetTransportName() = 0; + + protected: + IListenerTransport() {} + }; +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/transports/hostTransport.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/transports/hostTransport.cpp new file mode 100644 index 000000000..1ed6ea012 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/transports/hostTransport.cpp @@ -0,0 +1,130 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "hostTransport.h" +#include "ddPlatform.h" +#include "../routerCore.h" + +#define BUFFER_LENGTH 16 +#define RECV_BUFSIZE (sizeof(MessageBuffer) * 8) +#define SEND_BUFSIZE (sizeof(MessageBuffer) * 8) + +namespace DevDriver +{ + + HostListenerTransport::HostListenerTransport(const ListenerCreateInfo &createInfo) + : m_transportHandle(0) + { + DD_UNUSED(createInfo); + } + + HostListenerTransport::~HostListenerTransport() + { + Disable(); + } + + Result HostListenerTransport::ReceiveMessage(ConnectionInfo & connectionInfo, MessageBuffer & message, uint32 timeoutInMs) + { + Result result = Result::NotReady; + const auto waitTime = std::chrono::milliseconds((int64)timeoutInMs); + std::unique_lock lock(m_inboundMessages.mutex); + if (m_inboundMessages.signal.wait_for(lock, waitTime, [&] { return !m_inboundMessages.queue.empty(); })) + { + DD_ASSERT(m_transportHandle != 0); + message = m_inboundMessages.queue.front(); + m_inboundMessages.queue.pop_front(); + result = Result::Success; + connectionInfo.handle = m_transportHandle; + connectionInfo.size = 0; + } + lock.unlock(); + return result; + } + Result HostListenerTransport::TransmitMessage(const ConnectionInfo & connectionInfo, const MessageBuffer & message) + { + DD_ASSERT(connectionInfo.handle == m_transportHandle); + DD_UNUSED(connectionInfo); + + std::lock_guard lock(m_outboundMessages.mutex); + m_outboundMessages.queue.emplace_back(message); + m_outboundMessages.signal.notify_one(); + return Result::Success; + } + + Result HostListenerTransport::TransmitBroadcastMessage(const MessageBuffer & message) + { + std::lock_guard lock(m_outboundMessages.mutex); + m_outboundMessages.queue.emplace_back(message); + m_outboundMessages.signal.notify_one(); + return Result::Success; + } + + Result HostListenerTransport::Enable(RouterCore *pRouter, TransportHandle handle) + { + Result result = Result::Error; + if (m_transportHandle == 0) + { + m_transportHandle = handle; + m_transportThread.Start(pRouter, this); + result = Result::Success; + } + return result; + } + + Result HostListenerTransport::Disable() + { + Result result = Result::Error; + if (m_transportHandle != 0) + { + m_transportHandle = 0; + m_transportThread.Stop(); + result = Result::Success; + } + return result; + } + + Result HostListenerTransport::HostReadMessage(MessageBuffer & messageBuffer, uint32 timeoutInMs) + { + const auto waitTime = std::chrono::milliseconds((int64)timeoutInMs); + Result result = Result::NotReady; + std::unique_lock lock(m_outboundMessages.mutex); + if (m_outboundMessages.signal.wait_for(lock, waitTime, [&] { return !m_outboundMessages.queue.empty(); })) + { + messageBuffer = m_outboundMessages.queue.front(); + m_outboundMessages.queue.pop_front(); + result = Result::Success; + } + lock.unlock(); + return result; + } + + Result HostListenerTransport::HostWriteMessage(const MessageBuffer & messageBuffer) + { + DD_ASSERT(m_transportHandle != 0); + std::lock_guard lock(m_inboundMessages.mutex); + m_inboundMessages.queue.emplace_back(messageBuffer); + m_inboundMessages.signal.notify_one(); + return Result::Success; + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/transports/hostTransport.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/transports/hostTransport.h new file mode 100644 index 000000000..4cf466660 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/transports/hostTransport.h @@ -0,0 +1,74 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file udpListenerTransport.h +* @brief Class declaration for BaseMsgChannel +*********************************************************************************************************************** +*/ + +#pragma once + +#include "abstractListenerTransport.h" +#include +#include +#include +#include "../listenerCore.h" +#include "../transportThread.h" + +namespace DevDriver +{ + class HostListenerTransport : public IListenerTransport + { + public: + HostListenerTransport(const ListenerCreateInfo &createInfo); + ~HostListenerTransport() override; + + Result ReceiveMessage(ConnectionInfo &connectionInfo, MessageBuffer &message, uint32 timeoutInMs) override; + Result TransmitMessage(const ConnectionInfo &connectionInfo, const MessageBuffer &message) override; + Result TransmitBroadcastMessage(const MessageBuffer &message) override; + + Result Enable(RouterCore *pRouter, TransportHandle handle) override; + Result Disable() override; + + TransportHandle GetHandle() override { return m_transportHandle; }; + bool ForwardingConnection() override { return true; }; + const char* GetTransportName() override { return "Server"; }; + + Result HostReadMessage(MessageBuffer &messageBuffer, uint32 timeoutInMs); + Result HostWriteMessage(const MessageBuffer &messageBuffer); + protected: + TransportHandle m_transportHandle; + struct MessageQueue + { + std::deque queue; + std::condition_variable signal; + std::mutex mutex; + }; + + MessageQueue m_inboundMessages; + MessageQueue m_outboundMessages; + TransportThread m_transportThread; + }; +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/transports/socketTransport.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/transports/socketTransport.cpp new file mode 100644 index 000000000..8146c5d28 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/transports/socketTransport.cpp @@ -0,0 +1,166 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "socketTransport.h" +#include "ddPlatform.h" +#include +#include +#include +#include "../routerCore.h" + +namespace DevDriver +{ + // Take a TransportType and find the associated SocketType for the current platform + inline static SocketType TransportToSocketType(TransportType type) + { + SocketType result = SocketType::Unknown; + switch (type) + { +#ifndef _WIN32 + case TransportType::Local: + result = SocketType::Local; + break; +#endif + case TransportType::Remote: + result = SocketType::Udp; + break; + default: + DD_ALERT_REASON("Invalid transport type specified"); + break; + } + return result; + } + + SocketListenerTransport::SocketListenerTransport(TransportType type, const char *pAddress, uint32 port) : + m_socketType(TransportToSocketType(type)), + m_port(port), + m_listening(false) + { + if (pAddress != nullptr) + { + Platform::Strncpy(m_hostAddress, pAddress, sizeof(m_hostAddress)); + } + else + { + Platform::Strncpy(m_hostAddress, "0.0.0.0", sizeof(m_hostAddress)); + } + + if (type == TransportType::Local) + { + Platform::Snprintf(m_hostDescription, sizeof(m_hostDescription), "%s", m_hostAddress); + } + else if (type == TransportType::Remote) + { + Platform::Snprintf(m_hostDescription, sizeof(m_hostDescription), "%s:%u", m_hostAddress, m_port); + } + else + { + // Invalid type specified + Platform::Snprintf(m_hostDescription, sizeof(m_hostDescription), "Unknown"); + DD_ALERT_REASON("Unknown socket type requested"); + } + } + + SocketListenerTransport::~SocketListenerTransport() + { + if (m_listening) + Disable(); + } + + Result SocketListenerTransport::ReceiveMessage(ConnectionInfo& connectionInfo, MessageBuffer& message, uint32 timeoutInMs) + { + bool canRead = false; + bool exceptState = false; + connectionInfo.handle = m_transportHandle; + Result result = m_clientSocket.Select(&canRead, nullptr, &exceptState, timeoutInMs); + if (result == Result::Success) + { + if (exceptState) + { + result = Result::Error; + } + else if (canRead) + { + connectionInfo.size = sizeof(connectionInfo.data); + result = m_clientSocket.ReceiveFrom(reinterpret_cast(&connectionInfo.data[0]), + &connectionInfo.size, + reinterpret_cast(&message), + sizeof(MessageBuffer)); + } + else + { + result = Result::NotReady; + } + } + return result; + } + + Result SocketListenerTransport::TransmitMessage(const ConnectionInfo& connectionInfo, const MessageBuffer& message) + { + DD_ASSERT(connectionInfo.handle == m_transportHandle); + Result result = m_clientSocket.SendTo(reinterpret_cast(&connectionInfo.data[0]), + connectionInfo.size, + reinterpret_cast(&message), + sizeof(MessageHeader) + message.header.payloadSize); + return result; + } + + Result SocketListenerTransport::TransmitBroadcastMessage(const MessageBuffer& message) + { + DD_UNUSED(message); + + return Result::Error; + } + + Result SocketListenerTransport::Enable(RouterCore *pRouter, TransportHandle handle) + { + Result result = Result::Error; + + if (m_clientSocket.Init(true, m_socketType) == DevDriver::Result::Success) + { + char *address = nullptr; + if (m_hostAddress[0] != 0) + address = m_hostAddress; + if (m_clientSocket.Bind(address, m_port) == Result::Success) + { + result = Result::Success; + m_transportHandle = handle; + m_transportThread.Start(pRouter, this); + } + } + return result; + } + + Result SocketListenerTransport::Disable() + { + Result result = Result::Error; + if (m_transportHandle != 0) + { + m_transportHandle = 0; + m_transportThread.Stop(); + result = Result::Success; + } + return result; + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/transports/socketTransport.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/transports/socketTransport.h new file mode 100644 index 000000000..f3461877d --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/transports/socketTransport.h @@ -0,0 +1,70 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file socketTransport.h +* @brief Class declaration for SocketListenerTransport +*********************************************************************************************************************** +*/ + +#pragma once + +#include "abstractListenerTransport.h" +#include "../src/ddSocket.h" +#include "../transportThread.h" + +namespace DevDriver +{ + static_assert(sizeof(sockaddr) <= kConnectionInfoDataSize, "ConnectionInfo struct not large enough to hold address information"); + + class RouterCore; + + class SocketListenerTransport : public IListenerTransport + { + public: + SocketListenerTransport(TransportType type, const char *pAddress, uint32 port); + ~SocketListenerTransport() override; + + Result ReceiveMessage(ConnectionInfo &connectionInfo, MessageBuffer &message, uint32 timeoutInMs) override; + Result TransmitMessage(const ConnectionInfo &connectionInfo, const MessageBuffer &message) override; + Result TransmitBroadcastMessage(const MessageBuffer &message) override; + + Result Enable(RouterCore *pRouter, TransportHandle handle) override; + Result Disable() override; + + TransportHandle GetHandle() override { return m_transportHandle; }; + bool ForwardingConnection() override { return false; }; + const char* GetTransportName() override { return m_hostDescription; }; + + protected: + char m_hostAddress[kMaxStringLength]; + char m_hostDescription[kMaxStringLength]; + Socket m_clientSocket; + SocketType m_socketType; + uint32 m_port; + TransportHandle m_transportHandle; + bool m_listening; + TransportThread m_transportThread; + }; +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/transports/winPipeTransport.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/transports/winPipeTransport.cpp new file mode 100644 index 000000000..d29f3c7cd --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/transports/winPipeTransport.cpp @@ -0,0 +1,518 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "winPipeTransport.h" +#include "ddPlatform.h" +#include +#include +#include "../routerCore.h" + +#define BUFFER_LENGTH 16 +#define RECV_BUFSIZE (sizeof(MessageBuffer) * 8) +#define SEND_BUFSIZE (sizeof(MessageBuffer) * 8) + +namespace DevDriver +{ + static Result WaitOverlapped(HANDLE hPipe, OVERLAPPED* pOverlapped, DWORD *pBytesTransferred, DWORD waitTimeMs) + { + DWORD waitResult = WAIT_OBJECT_0; + Result result = Result::NotReady; + + //BOOL result = GetOverlappedResultEx(hPipe, pOverlapped, pBytesTransferred, waitTimeMs, FALSE); + + if (waitTimeMs > 0) + waitResult = WaitForSingleObject(pOverlapped->hEvent, waitTimeMs); + + if (waitResult == WAIT_OBJECT_0) + { + if (GetOverlappedResult(hPipe, pOverlapped, pBytesTransferred, FALSE)) + { + result = Result::Success; + } + else + { + result = (GetLastError() == ERROR_IO_INCOMPLETE) ? Result::NotReady : Result::Error; + } + } + else if (waitResult != WAIT_TIMEOUT) + { + result = Result::Error; + } + return result; + } + + void SetDebugPriviledges(bool enabled) + { + HANDLE hToken; + LUID SeDebugNameValue; + TOKEN_PRIVILEGES TokenPrivileges; + + if (OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken)) + { + if (LookupPrivilegeValue(nullptr, SE_DEBUG_NAME, &SeDebugNameValue)) + { + TokenPrivileges.PrivilegeCount = 1; + TokenPrivileges.Privileges[0].Luid = SeDebugNameValue; + TokenPrivileges.Privileges[0].Attributes = enabled ? SE_PRIVILEGE_ENABLED : 0; + + if (AdjustTokenPrivileges(hToken, FALSE, &TokenPrivileges, sizeof(TOKEN_PRIVILEGES), nullptr, nullptr)) + { + CloseHandle(hToken); + } + else + { + CloseHandle(hToken); + DD_PRINT(LogLevel::Error, "Couldn't adjust token privileges!"); + } + } + else + { + CloseHandle(hToken); + DD_PRINT(LogLevel::Error, "Couldn't look up privilege value!"); + } + } + else + { + DD_PRINT(LogLevel::Error, "Couldn't open process token!"); + } + } + + Result ReadMessage(PipeInfo &threadInfo, OVERLAPPED &oOverlap, MessageContext &messageContext, uint32 timeoutInMs) + { + Result result = Result::Error; + HANDLE hPipe = reinterpret_cast(threadInfo.pipeHandle); + DWORD receivedSize = 0; + + if (!threadInfo.ioPending) + { + + if (ReadFile(hPipe, &messageContext.message, sizeof(MessageBuffer), &receivedSize, &oOverlap)) + { + result = Result::Success; + } + else if (GetLastError() == ERROR_IO_PENDING) + { + threadInfo.ioPending = true; + } + } + + if (threadInfo.ioPending) + { + result = WaitOverlapped(hPipe, &oOverlap, &receivedSize, timeoutInMs); + //DD_ASSERT(result != Result::Error); + } + + if (result == Result::Success) + { + threadInfo.ioPending = false; + } + else if (result != Result::NotReady) + { + threadInfo.ioPending = false; + result = Result::Error; + } + + return result; + } + + void PipeListenerTransport::ListeningThreadFunc(PipeInfo *pipeInfo) + { + DD_ASSERT(pipeInfo != nullptr); + + OVERLAPPED oOverlap = {}; + oOverlap.Offset = 0; + oOverlap.OffsetHigh = 0; + oOverlap.hEvent = CreateEvent( + nullptr, // default security attribute + TRUE, // manual-reset event + FALSE, // initial state = unsignaled + nullptr); // unnamed event object + + pipeInfo->active = true; + + while (pipeInfo->active) + { + // Wait for the client to connect; if it succeeds, + // the function returns a nonzero value. If the function + // returns zero, GetLastError returns ERROR_PIPE_CONNECTED. + + HANDLE hPipe = INVALID_HANDLE_VALUE; + hPipe = CreateNamedPipeA( + m_pipeName, // Pipe name + PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED, // Can read/write and uses overlapped i/o + PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT, // Message oriented and blocking reads/writes + PIPE_UNLIMITED_INSTANCES, // Max. instances + SEND_BUFSIZE, // Output buffer size + RECV_BUFSIZE, // Input buffer size + 0, // Client time-out + nullptr); // Default security attribute + + if (hPipe == INVALID_HANDLE_VALUE) + { + DD_PRINT(LogLevel::Error, "[winPipeTransport] CreateNamedPipe failed, GLE=%d.", GetLastError()); + return; + } + + Result result = (ConnectNamedPipe(hPipe, &oOverlap) != FALSE) ? Result::Success : Result::Error; + + if (result != Result::Success) + { + DWORD dwErr = GetLastError(); + if (dwErr == ERROR_IO_PENDING) + { + DD_PRINT(LogLevel::Debug, "[winPipeTransport] Waiting for new client"); + + DWORD numBytes = 0; + + result = Result::NotReady; + + while ((pipeInfo->active) & (result == Result::NotReady)) + { + if (m_threadPool.deleteSet.size() > 0) + { + std::lock_guard lock(m_threadPool.mutex); + for (auto &threadInfo : m_threadPool.deleteSet) + { + // should already be inactive + threadInfo->active = false; + if (threadInfo->thread.joinable()) + threadInfo->thread.join(); + DisconnectNamedPipe(reinterpret_cast(threadInfo->pipeHandle)); + CloseHandle(reinterpret_cast(threadInfo->pipeHandle)); + CloseHandle(reinterpret_cast(threadInfo->readEvent)); + CloseHandle(reinterpret_cast(threadInfo->writeEvent)); + delete threadInfo; + } + m_threadPool.deleteSet.clear(); + } + result = WaitOverlapped(hPipe, &oOverlap, &numBytes, kWaitTimeoutInMs); + } + } + else if (dwErr == ERROR_PIPE_CONNECTED) + { + result = Result::Success; + } + } + + if (result == Result::Success) + { + DD_PRINT(LogLevel::Debug, "[winPipeTransport] New client connected, starting new thread"); + PipeInfo *newThread = new PipeInfo(); + newThread->pipeHandle = DD_PTR_TO_HANDLE(hPipe); + newThread->active = true; + + newThread->writeEvent = DD_PTR_TO_HANDLE(CreateEvent( + nullptr, // default security attribute + TRUE, // manual-reset event + FALSE, // initial state = unsignaled + nullptr)); // unnamed event object + + newThread->readEvent = DD_PTR_TO_HANDLE(CreateEvent( + nullptr, // default security attribute + TRUE, // manual-reset event + FALSE, // initial state = unsignaled + nullptr)); // unnamed event object + + newThread->thread = std::thread(&PipeListenerTransport::ReceivingThreadFunc, this, m_pRouter, newThread); + + if (!newThread->thread.joinable()) + { + DD_PRINT(LogLevel::Error, "[winPipeTransport] Thread creation failed!"); + DisconnectNamedPipe(hPipe); + CloseHandle(hPipe); + delete newThread; + } + } + else + { + if (result == Result::Error) + { + DD_PRINT(LogLevel::Error, "[winPipeTransport] Connection failed!"); + } + CloseHandle(hPipe); + } + // The client could not connect, so close the pipe. + } + } + + void PipeListenerTransport::ReceivingThreadFunc(RouterCore *pRouter, PipeInfo *pThreadInfo) + { + if ((pThreadInfo == nullptr) | (pRouter == nullptr)) + { + DD_PRINT(LogLevel::Error, "ERROR - Pipe Server Failure"); + return; + } + else + { + std::lock_guard lock(m_threadPool.mutex); + m_threadPool.threadMap.emplace(pThreadInfo->pipeHandle, pThreadInfo); + } + + pThreadInfo->active = true; + + DD_PRINT(LogLevel::Debug, "[winPipeTransport] New client thread started"); + + OVERLAPPED oOverlap = {}; + oOverlap.Offset = 0; + oOverlap.OffsetHigh = 0; + oOverlap.hEvent = reinterpret_cast(pThreadInfo->readEvent); + + MessageContext recvContext = {}; + recvContext.connectionInfo.handle = m_transportHandle; + recvContext.connectionInfo.size = sizeof(HANDLE); + memcpy(&recvContext.connectionInfo.data[0], &pThreadInfo->pipeHandle, sizeof(HANDLE)); + + RoutingCache cache(pRouter); + std::deque recvQueue; + std::deque retryQueue; + + // Loop until done reading + while (pThreadInfo->active) + { + size_t firstNewMessageIndex = recvQueue.size(); + DD_STATIC_CONST uint32 kReceiveDelayInMs = 10; + + // Check for new local messages. + Result result = ReadMessage(*pThreadInfo, oOverlap, recvContext, kReceiveDelayInMs); + while (result == Result::Success) + { + recvQueue.emplace_back(recvContext); + result = ReadMessage(*pThreadInfo, oOverlap, recvContext, kNoWait); + } + + size_t messageNumber = 0; + for (const auto &message : recvQueue) + { + messageNumber++; + // only requeue messages if it's the first time we've tried to send them + if ((cache.RouteMessage(message) == Result::NotReady) & (messageNumber > firstNewMessageIndex)) + { + retryQueue.emplace_back(message); + } + } + recvQueue.clear(); + recvQueue.swap(retryQueue); + + if (result == Result::Error) + { + pThreadInfo->active = false; + std::lock_guard threadLock(m_threadPool.mutex); + if (m_threadPool.threadMap.erase(pThreadInfo->pipeHandle) > 0) + { + m_threadPool.deleteSet.emplace(pThreadInfo); + } + } + } + } + + PipeListenerTransport::PipeListenerTransport(const char* pPipeName) : + m_listening(false), + m_listenThread(), + m_pRouter(nullptr) + { + DD_ASSERT(pPipeName != nullptr); + Platform::Strncpy(&m_pipeName[0], pPipeName, sizeof(m_pipeName)); + } + + PipeListenerTransport::~PipeListenerTransport() + { + if (m_listening) + Disable(); + } + + Result PipeListenerTransport::ReceiveMessage(ConnectionInfo &connectionInfo, MessageBuffer &message, uint32 timeoutInMs) + { + DD_UNUSED(connectionInfo); + DD_UNUSED(message); + DD_UNUSED(timeoutInMs); + return Result::Error; + } + + Result PipeListenerTransport::TransmitMessage(const ConnectionInfo & connectionInfo, const MessageBuffer & message) + { + Result result = Result::Error; + DD_ASSERT(connectionInfo.handle == m_transportHandle); + DD_ASSERT(connectionInfo.size == sizeof(HANDLE)); + + const HANDLE &hPipe = *reinterpret_cast(&connectionInfo.data[0]); + PipeInfo *pThreadInfo = nullptr; + + std::unique_lock lock(m_threadPool.mutex); + auto find = m_threadPool.threadMap.find(DD_PTR_TO_HANDLE(hPipe)); + if (find != m_threadPool.threadMap.end()) + { + pThreadInfo = find->second; + } + lock.unlock(); + + if (pThreadInfo != nullptr) + { + + DWORD cbWritten = 0; + DWORD totalMessageSize = sizeof(MessageHeader) + message.header.payloadSize; + OVERLAPPED oOverlap = {}; + + std::lock_guard guard(pThreadInfo->lock); + HANDLE hEvent = reinterpret_cast(pThreadInfo->writeEvent); + + oOverlap.hEvent = hEvent; + + BOOL fSuccess = WriteFile(hPipe, + &message, // buffer to write from + totalMessageSize, // number of bytes to write + &cbWritten, // number of bytes written + &oOverlap); // not overlapped I/O + + if (!fSuccess) + { + DWORD dwErr = GetLastError(); + if (dwErr == ERROR_IO_PENDING) + { + Result waitResult = WaitOverlapped(hPipe, &oOverlap, &cbWritten, kInfiniteTimeout); + if (waitResult == Result::Success) + { + fSuccess = TRUE; + } + else + { + DD_ALERT_REASON("Wait on pipe write failed."); + } + } + } + + if (fSuccess != FALSE) + { + result = Result::Success; + } else + { + + pThreadInfo->active = false; + lock.lock(); + if (m_threadPool.threadMap.erase(pThreadInfo->pipeHandle) > 0) + { + m_threadPool.deleteSet.emplace(pThreadInfo); + } + lock.unlock(); + } + + } + + //DD_ASSERT(result != Result::Error); + return result; + } + + Result PipeListenerTransport::TransmitBroadcastMessage(const MessageBuffer & message) + { + DD_UNUSED(message); + return Result::Error; + } + + Result PipeListenerTransport::Enable(RouterCore *pRouter, TransportHandle handle) + { + Result result = Result::Error; + SetDebugPriviledges(true); + + HANDLE hPipe = INVALID_HANDLE_VALUE; + hPipe = CreateNamedPipeA( + m_pipeName, // Pipe name + PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED, // Can read/write and uses overlapped i/o + PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT, // Message oriented and blocking reads/writes + PIPE_UNLIMITED_INSTANCES, // Max. instances + SEND_BUFSIZE, // Output buffer size + RECV_BUFSIZE, // Input buffer size + 0, // Client time-out + nullptr); // Default security attribute + + if (hPipe != INVALID_HANDLE_VALUE) + { + CloseHandle(hPipe); + + m_transportHandle = handle; + m_pRouter = pRouter; + + m_listenThread.active = true; + m_listenThread.thread = std::thread(&PipeListenerTransport::ListeningThreadFunc, this, &m_listenThread); + + if (m_listenThread.thread.joinable()) + { + result = Result::Success; + m_listening = true; + } + else + { + m_transportHandle = 0; + m_pRouter = nullptr; + SetDebugPriviledges(false); + } + } + else if (GetLastError() == ERROR_ACCESS_DENIED) + { + result = Result::Unavailable; + } + return result; + } + + Result PipeListenerTransport::Disable() + { + Result result = Result::Error; + if (m_listening) + { + m_listenThread.active = false; + if (m_listenThread.thread.joinable()) + m_listenThread.thread.join(); + + std::lock_guard lock(m_threadPool.mutex); + for (auto &pThreadInfo : m_threadPool.deleteSet) + { + // should already be inactive + pThreadInfo->active = false; + if (pThreadInfo->thread.joinable()) + pThreadInfo->thread.join(); + DisconnectNamedPipe(reinterpret_cast(pThreadInfo->pipeHandle)); + CloseHandle(reinterpret_cast(pThreadInfo->pipeHandle)); + CloseHandle(reinterpret_cast(pThreadInfo->readEvent)); + CloseHandle(reinterpret_cast(pThreadInfo->writeEvent)); + delete pThreadInfo; + } + m_threadPool.deleteSet.clear(); + for (auto &pair : m_threadPool.threadMap) + { + pair.second->active = false; + if (pair.second->thread.joinable()) + pair.second->thread.join(); + DisconnectNamedPipe(reinterpret_cast(pair.second->pipeHandle)); + CloseHandle(reinterpret_cast(pair.second->pipeHandle)); + CloseHandle(reinterpret_cast(pair.second->readEvent)); + CloseHandle(reinterpret_cast(pair.second->writeEvent)); + delete pair.second; + } + m_transportHandle = 0; + m_threadPool.threadMap.clear(); + m_listening = false; + SetDebugPriviledges(false); + } + // todo: unregister all clients + return result; + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/transports/winPipeTransport.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/transports/winPipeTransport.h new file mode 100644 index 000000000..fe896391e --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/listener/transports/winPipeTransport.h @@ -0,0 +1,94 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file udpListenerTransport.h +* @brief Class declaration for BaseMsgChannel +*********************************************************************************************************************** +*/ + +#pragma once + +#include "abstractListenerTransport.h" +#include +#include +#include +#include +#include +#include +#include "../transportThread.h" +#include "msgTransport.h" + +namespace DevDriver +{ + class RouterCore; + + struct PipeInfo + { + std::mutex lock; + std::thread thread; + volatile bool active; + Handle pipeHandle; + Handle writeEvent; + Handle readEvent; + bool ioPending; + }; + + class PipeListenerTransport : public IListenerTransport + { + public: + PipeListenerTransport(const char* pPipeName); + ~PipeListenerTransport() override; + + Result ReceiveMessage(ConnectionInfo &connectionInfo, MessageBuffer &message, uint32 timeoutInMs) override; + Result TransmitMessage(const ConnectionInfo &connectionInfo, const MessageBuffer &message) override; + Result TransmitBroadcastMessage(const MessageBuffer &message) override; + + Result Enable(RouterCore *pRouter, TransportHandle handle) override; + Result Disable() override; + + TransportHandle GetHandle() override { return m_transportHandle; }; + bool ForwardingConnection() override { return false; }; + const char* GetTransportName() override { return "Local Pipe"; }; + protected: + char m_pipeName[kMaxStringLength]; + TransportHandle m_transportHandle; + + bool m_listening; + + struct + { + std::unordered_map threadMap; + std::unordered_set deleteSet; + std::mutex mutex; + } m_threadPool; + + PipeInfo m_listenThread; + RouterCore* m_pRouter; + + void ListeningThreadFunc(PipeInfo *threadInfo); + void ReceivingThreadFunc(RouterCore *pRouter, PipeInfo *threadInfo); + DD_STATIC_CONST uint32 kWaitTimeoutInMs = 100; + }; +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/baseProtocolClient.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/baseProtocolClient.cpp new file mode 100644 index 000000000..0439a94c5 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/baseProtocolClient.cpp @@ -0,0 +1,186 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "baseProtocolClient.h" +#include "msgChannel.h" + +namespace DevDriver +{ + BaseProtocolClient::BaseProtocolClient(IMsgChannel* pMsgChannel, Protocol protocol, Version minVersion, Version maxVersion) + : m_pMsgChannel(pMsgChannel) + , m_protocol(protocol) + , m_minVersion(minVersion) + , m_maxVersion(maxVersion) + , m_pSession() + , m_pendingOperationEvent(false) + , m_connectResult(Result::Error) + , m_state(ClientState::Disconnected) + { + DD_ASSERT(m_pMsgChannel != nullptr); + } + + bool BaseProtocolClient::IsConnected() const + { + return (m_state == ClientState::Connected); + } + +#if !DD_VERSION_SUPPORTS(GPUOPEN_SESSION_INTERFACE_CLEANUP_VERSION) + // Orphans the current session associated with the client object and moves to the disconnected state + // This function is intended for situations where the external code knows the remote client has disconnected + // before the message channel subsystem. In this type of situation, orphaning the client instead of using a regular + // disconnect call can avoid the delay/timeout that occurs when the message channel subsystem attempts to disconnect + // gracefully. + void BaseProtocolClient::Orphan() + { + if (!m_pSession.IsNull()) + { + m_pSession->Close(Result::Success); + m_pSession.Clear(); + } + + m_state = ClientState::Disconnected; + } +#endif + + ClientId BaseProtocolClient::GetRemoteClientId() const + { + if (!m_pSession.IsNull()) + { + return m_pSession->GetDestinationClientId(); + } + return 0; + } + + BaseProtocolClient::~BaseProtocolClient() + { + if (!m_pSession.IsNull()) + { + m_pSession->Close(Result::Success); + m_pSession.Clear(); + } + // Reset the state to make sure all owned objects are released before destruction. + ResetState(); + } + + Version BaseProtocolClient::GetSessionVersion() const + { + Version version = 0; + if (!m_pSession.IsNull()) + { + version = m_pSession->GetVersion(); + } + return version; + } + + void BaseProtocolClient::SessionEstablished(const SharedPointer& pSession) + { + + // We should never be overwriting an existing session pointer here. + DD_ASSERT(m_pSession.IsNull()); + + m_state = ClientState::Connected; + m_connectResult = Result::Success; + m_pSession = pSession; + + m_pendingOperationEvent.Signal(); + } + + void BaseProtocolClient::UpdateSession(const SharedPointer& pSession) + { + DD_UNUSED(pSession); + + // Do nothing by default + } + + void BaseProtocolClient::SessionTerminated(const SharedPointer& pSession, Result terminationReason) + { + const bool wasConnecting = (m_state == ClientState::Connecting); + DD_ASSERT(wasConnecting | (pSession == m_pSession)); + + DD_UNUSED(wasConnecting); + DD_UNUSED(pSession); + + m_state = ClientState::Disconnected; + + // If the session was terminated and we were previously trying to make a connection, then we need to signal + // the connection finished event to unblock the connecting thread. + m_connectResult = terminationReason; + m_pendingOperationEvent.Signal(); + m_pSession.Clear(); + } + + Result BaseProtocolClient::Connect(ClientId clientId) + { + Result result = Result::Error; + + if (m_state == ClientState::Disconnected) + { + // If a session terminates unexpectedly, we may end up with a valid session object + // Even in the disconnected state. This dead session object should be deleted. It can't + // be deleted immediately upon termination because other parts of the client code could + // still be using it. + m_pSession.Clear(); + + ResetState(); + + DD_ASSERT(m_pMsgChannel != nullptr); + + m_state = ClientState::Connecting; + m_pendingOperationEvent.Clear(); + + result = m_pMsgChannel->ConnectProtocolClient(this, clientId); + if (result == Result::Success) + { + // Only wait on the event if we successfully establish the session. If we fail to establish the + // session, the event will never be signaled. + + // todo - implement more robust timeout system + m_pendingOperationEvent.Wait(kInfiniteTimeout); + result = m_connectResult; + } + else + { + // Restore the state to Disconnected if we fail to establish the session. + m_state = ClientState::Disconnected; + } + } + return result; + } + + void BaseProtocolClient::Disconnect() + { + if (IsConnected()) + { + m_pendingOperationEvent.Clear(); + m_pSession->Shutdown(Result::Success); + while (!m_pSession.IsNull()) + { + // todo - implement more robust timeout system + m_pendingOperationEvent.Wait(kDefaultRetryTimeoutInMs); + } + } + ResetState(); + } + +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/baseProtocolServer.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/baseProtocolServer.cpp new file mode 100644 index 000000000..a0595f586 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/baseProtocolServer.cpp @@ -0,0 +1,108 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "baseProtocolServer.h" +#include "msgChannel.h" + +namespace DevDriver +{ + BaseProtocolServer::BaseProtocolServer(IMsgChannel* pMsgChannel, Protocol protocol, Version minVersion, Version maxVersion) + : m_pMsgChannel(pMsgChannel) + , m_protocol(protocol) + , m_minVersion(minVersion) + , m_maxVersion(maxVersion) + , m_isFinalized(false) + { + DD_ASSERT(m_pMsgChannel != nullptr); + } + + Result BaseProtocolServer::SendPayload(ISession* pSession, const SizedPayloadContainer* pPayload, uint32 timeoutInMs) + { + DD_ASSERT(pSession != nullptr); + DD_ASSERT(pPayload != nullptr); + + return pSession->Send(pPayload->payloadSize, pPayload->payload, timeoutInMs); + } + + Result BaseProtocolServer::ReceivePayload(ISession* pSession, SizedPayloadContainer* pPayload, uint32 timeoutInMs) + { + DD_ASSERT(pSession != nullptr); + DD_ASSERT(pPayload != nullptr); + + return pSession->Receive(sizeof(pPayload->payload), pPayload->payload, &pPayload->payloadSize, timeoutInMs); + } + + BaseProtocolServer::~BaseProtocolServer() + { + } + + bool BaseProtocolServer::GetSupportedVersion(Version minVersion, Version maxVersion, Version *version) const + { + DD_ASSERT(minVersion <= maxVersion); + DD_ASSERT(version != nullptr); + bool foundVersion = false; + + const bool minLessThanEqMax = (minVersion <= m_maxVersion); + const bool maxLessThanEqMax = (maxVersion <= m_maxVersion); + const bool maxGreaterThanMax = !maxLessThanEqMax; + const bool maxGreaterThanEqMin = (maxVersion >= m_minVersion); + + // We need to find the highest value intersection between the input range and our range. To do this, we are + // concerned primarily with two cases: if the upper bound of the range provided falls inside our range, or if + // the upper bound of our range falls within the range it provided. To determine this we perform two tests: + // * Check to see if (iMax <= Max) and (iMax >= Min). If this is true, than we use their maximum value. + // * Check to see if (iMax > Max) and (iMin <= Max). If this is true, we use our maximum value. + // We additionally attempt to report the closest bound (e.g., minimum or maximum) in the case where the they + // don't overlap. This (hopefully) will allow them to determine whether their version was too low or too high. + + // If the max version requested is within the range supported by the server, we pick it by default + if (maxLessThanEqMax & maxGreaterThanEqMin) + { + *version = maxVersion; + foundVersion = true; + } + // Otherwise, we check to ensure that our max version is within the range provided to us. + else if (maxGreaterThanMax & minLessThanEqMax) + { + *version = m_maxVersion; + foundVersion = true; + } + else + { + // If the min version requested is not less than or equal to our max, we return the max version supported. + // Otherwise we assume that the max requested is less than our min version + *version = (!minLessThanEqMax) ? m_maxVersion : m_minVersion; + } + + return foundVersion; + } + + void BaseProtocolServer::Finalize() + { + // Finalize should only be called once. + DD_ASSERT(m_isFinalized == false); + + m_isFinalized = true; + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/ddClientURIService.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/ddClientURIService.cpp new file mode 100644 index 000000000..3a75b0f57 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/ddClientURIService.cpp @@ -0,0 +1,230 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "ddClientURIService.h" +#include "msgChannel.h" +#include "ddTransferManager.h" + +namespace DevDriver +{ + // ===================================================================================================================== + ClientURIService::ClientURIService() + : m_pMsgChannel(nullptr) + { + } + + // ===================================================================================================================== + ClientURIService::~ClientURIService() + { + } + + // ===================================================================================================================== + Result ClientURIService::HandleRequest(URIRequestContext* pContext) + { + DD_ASSERT(pContext != nullptr); + + Result result = Result::Error; + + // We can only handle requests if a valid message channel has been bound. + if (m_pMsgChannel != nullptr) + { + // We currently only handle the "info" command. + // All other commands will result in an error. + if (strcmp(pContext->pRequestArguments, "info") == 0) + { + // Fetch the desired information about the client. + const ClientId clientId = m_pMsgChannel->GetClientId(); + const ClientInfoStruct& clientInfo = m_pMsgChannel->GetClientInfo(); + + // @todo: Replace with a string builder utility class. + char textBuffer[256]; + + // Write all the info into the response block as plain text. + auto& pBlock = pContext->pResponseBlock; + + // Write the header + Platform::Snprintf(textBuffer, sizeof(textBuffer), "--- Client Information ---"); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + // Write the gpuopen library interface version + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nClient Available Interface Version: %u.%u", GPUOPEN_INTERFACE_MAJOR_VERSION, GPUOPEN_INTERFACE_MINOR_VERSION); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + // Write the gpuopen client interface version + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nClient Supported Interface Major Version: %u", GPUOPEN_CLIENT_INTERFACE_MAJOR_VERSION); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + // Write the client message bus version + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nClient Supported Message Bus Version: %u", kMessageVersion); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + // Write the client transport type + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nClient Transport: %s", m_pMsgChannel->GetTransportName()); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + // Write the client id + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nClient Id: %u", static_cast(clientId)); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + // Write the client type + const char* pClientTypeString = "Unknown"; + switch (clientInfo.metadata.clientType) + { + case Component::Server: pClientTypeString = "Server"; break; + case Component::Tool: pClientTypeString = "Tool"; break; + case Component::Driver: pClientTypeString = "Driver"; break; + default: DD_ALERT_ALWAYS(); break; + } + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nClient Type: %s", pClientTypeString); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + // Write the client name + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nClient Name: %s", clientInfo.clientName); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + // Write the client description + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nClient Description: %s", clientInfo.clientDescription); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + // Write the client operating system + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nClient Operating System: %s", DD_OS_STRING " " DD_ARCH_STRING); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + // Only print protocols + status flags in debug builds for now. +#if !defined(NDEBUG) + { + IProtocolServer* pServer = m_pMsgChannel->GetProtocolServer(Protocol::Transfer); + if (pServer != nullptr) + { + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nClient Transfer Protocol Supported Versions: (%u -> %u)", pServer->GetMinVersion(), pServer->GetMaxVersion()); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + } + } + + { + IProtocolServer* pServer = m_pMsgChannel->GetProtocolServer(Protocol::URI); + if (pServer != nullptr) + { + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nClient URI Protocol Supported Versions: (%u -> %u)", pServer->GetMinVersion(), pServer->GetMaxVersion()); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + } + } + + // Write the protocols + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nClient Logging Protocol Support: %u", clientInfo.metadata.protocols.logging); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + if (clientInfo.metadata.protocols.logging) + { + IProtocolServer* pServer = m_pMsgChannel->GetProtocolServer(Protocol::Logging); + if (pServer != nullptr) + { + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nClient Logging Protocol Supported Versions: (%u -> %u)", pServer->GetMinVersion(), pServer->GetMaxVersion()); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + } + } + + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nClient Settings Protocol Support: %u", clientInfo.metadata.protocols.settings); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + if (clientInfo.metadata.protocols.settings) + { + IProtocolServer* pServer = m_pMsgChannel->GetProtocolServer(Protocol::Settings); + if (pServer != nullptr) + { + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nClient Settings Protocol Supported Versions: (%u -> %u)", pServer->GetMinVersion(), pServer->GetMaxVersion()); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + } + } + + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nClient Driver Control Protocol Support: %u", clientInfo.metadata.protocols.driverControl); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + if (clientInfo.metadata.protocols.driverControl) + { + IProtocolServer* pServer = m_pMsgChannel->GetProtocolServer(Protocol::DriverControl); + if (pServer != nullptr) + { + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nClient Driver Control Protocol Supported Versions: (%u -> %u)", pServer->GetMinVersion(), pServer->GetMaxVersion()); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + } + } + + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nClient RGP Protocol Support: %u", clientInfo.metadata.protocols.rgp); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + if (clientInfo.metadata.protocols.rgp) + { + IProtocolServer* pServer = m_pMsgChannel->GetProtocolServer(Protocol::RGP); + if (pServer != nullptr) + { + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nClient RGP Protocol Supported Versions: (%u -> %u)", pServer->GetMinVersion(), pServer->GetMaxVersion()); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + } + } + + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nClient ETW Protocol Support: %u", clientInfo.metadata.protocols.etw); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + if (clientInfo.metadata.protocols.etw) + { + IProtocolServer* pServer = m_pMsgChannel->GetProtocolServer(Protocol::ETW); + if (pServer != nullptr) + { + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nClient ETW Protocol Supported Versions: (%u -> %u)", pServer->GetMinVersion(), pServer->GetMaxVersion()); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + } + } + + // Write the status flags + const uint32 developerModeEnabled = ((clientInfo.metadata.status & static_cast(ClientStatusFlags::DeveloperModeEnabled)) != 0) ? 1 : 0; + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nClient Developer Mode Status Flag: %u", developerModeEnabled); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + const uint32 haltOnConnect = ((clientInfo.metadata.status & static_cast(ClientStatusFlags::HaltOnConnect)) != 0) ? 1 : 0; + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nClient Halt On Connect Status Flag: %u", haltOnConnect); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + const uint32 gpuCrashDumpsEnabled = ((clientInfo.metadata.status & static_cast(ClientStatusFlags::GpuCrashDumpsEnabled)) != 0) ? 1 : 0; + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nClient Gpu Crash Dumps Enabled Status Flag: %u", gpuCrashDumpsEnabled); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + const uint32 pipelineDumpsEnabled = ((clientInfo.metadata.status & static_cast(ClientStatusFlags::PipelineDumpsEnabled)) != 0) ? 1 : 0; + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nClient Pipeline Dumps Enabled Status Flag: %u", pipelineDumpsEnabled); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); +#endif + + // Write the process id + Platform::Snprintf(textBuffer, sizeof(textBuffer), "\nClient Process Id: %u", clientInfo.processId); + pBlock->Write(reinterpret_cast(textBuffer), strlen(textBuffer)); + + pContext->responseDataFormat = URIDataFormat::Text; + + result = Result::Success; + } + } + + return result; + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/ddClientURIService.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/ddClientURIService.h new file mode 100644 index 000000000..75a10a9e7 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/ddClientURIService.h @@ -0,0 +1,62 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file ddClientURIService.h +* @brief Class declaration for ClientURIService +*********************************************************************************************************************** +*/ + +#pragma once + +#include "ddUriInterface.h" + +namespace DevDriver +{ + class IMsgChannel; + + // String used to identify the client URI service + DD_STATIC_CONST char kClientURIServiceName[] = "client"; + + class ClientURIService : public IService + { + public: + ClientURIService(); + ~ClientURIService(); + + // Returns the name of the service + const char* GetName() const override final { return kClientURIServiceName; } + + // Binds a message channel to the service + // All requests will be handled using the currently bound message channel + void BindMessageChannel(IMsgChannel* pMsgChannel) { m_pMsgChannel = pMsgChannel; } + + // Handles an incoming URI request + Result HandleRequest(URIRequestContext* pContext) override final; + + private: + // Currently bound message channel + IMsgChannel* m_pMsgChannel; + }; +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/ddSocket.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/ddSocket.h new file mode 100644 index 000000000..fb421e5f1 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/ddSocket.h @@ -0,0 +1,126 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file socket.h +* @brief PAL utility collection Socket class declaration. +*********************************************************************************************************************** +*/ + +#pragma once + +#include "gpuopen.h" +#include "ddPlatform.h" + +#if defined(_WIN32) +#ifndef WIN32_LEAN_AND_MEAN +#define WIN32_LEAN_AND_MEAN +#include +#include +#undef WIN32_LEAN_AND_MEAN +#else +#include +#include +#endif +#pragma comment(lib, "ws2_32.lib") +#else +#include +#include +#include +#include +#endif + +namespace DevDriver +{ + enum class SocketType : uint32 + { + Unknown = 0, + Tcp, + Udp, + Local + }; + + /** + *********************************************************************************************************************** + * @brief Encapsulates details of socket management for various platforms. + *********************************************************************************************************************** + */ + class Socket + { + public: + Socket(); + + /// Releases any OS-specific objects if they haven't previously been released in an explicit Destroy() call. + ~Socket(); + + /// Allocates/initializes the OS-specific object representing the socket. Clients must call this method + /// before using this object. + /// + /// @returns Success if the object was successfully initialized, or ErrorOutOfMemory if allocation of the + /// OS-specific object failed. + Result Init(bool isNonBlocking, SocketType socketType); + + Result Connect(const char* pAddress, uint32 port); + + Result Select(bool* pReadState, bool* pWriteState, bool* pExceptState, uint32 timeoutInMs); + + Result Bind(const char* pAddress, uint32 port); + + Result Listen(uint32 backlog); + + Result Accept(Socket* pClientSocket); + + Result Send(const uint8* pData, size_t dataSize, size_t* pBytesSent); + + Result SendTo(const void* pSockAddr, size_t addrSize, const uint8* pData, size_t dataSize); + + Result Receive(uint8* pBuffer, size_t bufferSize, size_t* pBytesReceived); + + Result ReceiveFrom(void *pSockAddr, size_t *addrSize, uint8* pBuffer, size_t bufferSize); + + Result Close(); + + Result GetSocketName(char *pAddress, size_t addrLen, uint32 *pPort); + + Result LookupAddressInfo(const char* pAddress, uint32 port, size_t addressInfoSize, char* pAddressInfo, size_t *pAddressSize); + + private: +#if defined(DD_WINDOWS) + using OsSocketType = SOCKET; +#else + using OsSocketType = int; +#endif + + OsSocketType m_osSocket; + bool m_isNonBlocking; + SocketType m_socketType; + addrinfo m_hints; +#if !defined(DD_WINDOWS) + char m_address[kMaxStringLength]; + size_t m_addressSize; +#endif + Result InitAsClient(OsSocketType socket, const char* pAddress, uint32 port, bool isNonBlocking); + }; + +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/ddTransferManager.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/ddTransferManager.cpp new file mode 100644 index 000000000..20bd4e53e --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/ddTransferManager.cpp @@ -0,0 +1,335 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "ddTransferManager.h" +#include "protocols/ddTransferServer.h" +#include "messageChannel.h" + +namespace DevDriver +{ + namespace TransferProtocol + { + // ============================================================================================================ + TransferManager::TransferManager(const AllocCb& allocCb) + : m_pMessageChannel(nullptr) + , m_pSessionManager(nullptr) + , m_pTransferServer(nullptr) + , m_allocCb(allocCb) + , m_rng() + , m_mutex() + , m_registeredServerBlocks(allocCb) + {} + + // ============================================================================================================ + TransferManager::~TransferManager() + { + Destroy(); + } + + // ============================================================================================================ + Result TransferManager::Init(IMsgChannel* pMsgChannel, SessionManager* pSessionManager) + { + DD_ASSERT(pMsgChannel != nullptr); + DD_ASSERT(pSessionManager != nullptr); + + m_pMessageChannel = pMsgChannel; + m_pSessionManager = pSessionManager; + + m_pTransferServer = DD_NEW(TransferServer, m_allocCb)(m_pMessageChannel, this); + if (m_pTransferServer != nullptr) + { + m_pSessionManager->RegisterProtocolServer(m_pTransferServer); + } + + return (m_pTransferServer != nullptr) ? Result::Success : Result::Error; + } + + // ============================================================================================================ + void TransferManager::Destroy() + { + if (m_pTransferServer != nullptr) + { + m_pSessionManager->UnregisterProtocolServer(m_pTransferServer); + DD_DELETE(m_pTransferServer, m_allocCb); + m_pTransferServer = nullptr; + } + } + + // ============================================================================================================ + SharedPointer TransferManager::OpenServerBlock() + { + Platform::LockGuard lock(m_mutex); + + BlockId newBlockId = kInvalidBlockId; + do + { + newBlockId = m_rng.Generate(); + } while ((newBlockId == kInvalidBlockId) && m_registeredServerBlocks.Contains(newBlockId)); + + // Attempt to allocate a new server block + SharedPointer pBlock = SharedPointer::Create(m_allocCb, + m_allocCb, + newBlockId); + if (!pBlock.IsNull()) + { + m_registeredServerBlocks.Create(newBlockId, pBlock); + } + + return pBlock; + } + + // ============================================================================================================ + SharedPointer TransferManager::GetServerBlock(BlockId serverBlockId) + { + SharedPointer pBlock = SharedPointer(); + Platform::LockGuard lock(m_mutex); + const auto blockIter = m_registeredServerBlocks.Find(serverBlockId); + if (blockIter != m_registeredServerBlocks.End()) + { + pBlock = blockIter->value; + } + return pBlock; + } + + // ============================================================================================================ + void TransferManager::CloseServerBlock(SharedPointer& pBlock) + { + if (!pBlock.IsNull()) + { + Platform::LockGuard lock(m_mutex); + + m_registeredServerBlocks.Erase(pBlock->GetBlockId()); + + // Clear the external shared pointer to the block. + pBlock.Clear(); + } + } + + // ============================================================================================================ + PullBlock* TransferManager::OpenPullBlock(ClientId clientId, BlockId blockId) + { + PullBlock* pBlock = DD_NEW(PullBlock, m_allocCb)(m_pMessageChannel, blockId); + if (pBlock != nullptr) + { + // Connect to the remote client and request a transfer. + Result result = pBlock->m_transferClient.Connect(clientId); + if (result == Result::Success) + { + result = pBlock->m_transferClient.RequestPullTransfer(blockId, &pBlock->m_blockDataSize); + } + + // If we fail the transfer or connection, destroy the block. + if (result != Result::Success) + { + pBlock->m_transferClient.Disconnect(); + DD_DELETE(pBlock, m_allocCb); + pBlock = nullptr; + } + } + return pBlock; + } + + // ============================================================================================================ + void TransferManager::ClosePullBlock(PullBlock** ppBlock) + { + DD_ASSERT(ppBlock != nullptr); + + TransferProtocol::TransferClient& transferClient = (*ppBlock)->m_transferClient; + if (transferClient.IsTransferInProgress()) + { + // Attempt to abort the transfer if there's currently one in progress. + const Result result = transferClient.AbortPullTransfer(); + DD_UNUSED(result); + } + + transferClient.Disconnect(); + DD_DELETE((*ppBlock), m_allocCb); + *ppBlock = nullptr; + } + + // ============================================================================================================ + PushBlock* TransferManager::OpenPushBlock(ClientId clientId, BlockId blockId, size_t blockSize) + { + PushBlock* pBlock = DD_NEW(PushBlock, m_allocCb)(m_pMessageChannel, blockId); + if (pBlock != nullptr) + { + // Connect to the remote client and request a transfer. + Result result = pBlock->m_transferClient.Connect(clientId); + if (result == Result::Success) + { + result = pBlock->m_transferClient.RequestPushTransfer(blockId, blockSize); + } + + // If we fail the transfer or connection, destroy the block. + if (result != Result::Success) + { + pBlock->m_transferClient.Disconnect(); + DD_DELETE(pBlock, m_allocCb); + pBlock = nullptr; + } + } + return pBlock; + } + + // ============================================================================================================ + void TransferManager::ClosePushBlock(PushBlock** ppBlock) + { + DD_ASSERT(ppBlock != nullptr); + + TransferProtocol::TransferClient& transferClient = (*ppBlock)->m_transferClient; + if (transferClient.IsTransferInProgress()) + { + // Attempt to abort the transfer if there's currently one in progress. + const Result result = transferClient.ClosePushTransfer(true); + DD_ASSERT(result == Result::Aborted); + DD_UNUSED(result); + } + + transferClient.Disconnect(); + DD_DELETE((*ppBlock), m_allocCb); + *ppBlock = nullptr; + } + + // ============================================================================================================ + void ServerBlock::Write(const uint8* pSrcBuffer, size_t numBytes) + { + // Writes can only be performed on blocks that are not closed. + DD_ASSERT(m_isClosed == false); + + if (numBytes > 0) + { + // Calculate how many bytes we have available. + const size_t blockCapacityInBytes = (m_chunks.Size() * kTransferChunkSizeInBytes); + const size_t bytesAvailable = (blockCapacityInBytes - m_blockDataSize); + + // Allocate more chunks if necessary. + if (bytesAvailable < numBytes) + { + const size_t additionalBytesRequired = (numBytes - bytesAvailable); + const size_t numChunksRequired = + (Platform::Pow2Align(additionalBytesRequired, kTransferChunkSizeInBytes) / kTransferChunkSizeInBytes); + m_chunks.Resize(m_chunks.Size() + numChunksRequired); + } + + // Copy the new data into the block + uint8* pData = (reinterpret_cast(m_chunks.Data()) + m_blockDataSize); + memcpy(pData, pSrcBuffer, numBytes); + m_crc32 = CRC32(pData, numBytes, m_crc32); + m_blockDataSize += numBytes; + } + } + + // ============================================================================================================ + void ServerBlock::Close() + { + DD_ASSERT(m_isClosed == false); + + m_isClosed = true; + } + + // ============================================================================================================ + void ServerBlock::Reset() + { + m_isClosed = false; + m_blockDataSize = 0; + m_crc32 = 0; + } + + // ============================================================================================================ + void ServerBlock::Reserve(size_t bytes) + { + if (!m_isClosed) + { + m_chunks.Reserve(Platform::Pow2Align(bytes, kTransferChunkSizeInBytes) / kTransferChunkSizeInBytes); + } + } + + // ============================================================================================================ + void ServerBlock::BeginTransfer() + { + m_pendingTransfersMutex.Lock(); + + // Increment the number of pending transfers. + ++m_numPendingTransfers; + + // Reset the event if this is the first transfer that's starting on this block. + if (m_numPendingTransfers == 1) + { + m_transfersCompletedEvent.Clear(); + } + + m_pendingTransfersMutex.Unlock(); + } + + // ============================================================================================================ + void ServerBlock::EndTransfer() + { + m_pendingTransfersMutex.Lock(); + + // We should always have pending transfers when end is called. + DD_ASSERT(m_numPendingTransfers > 0); + + // Decrement the number of pending transfers. + --m_numPendingTransfers; + + // Signal the event if this was the last transfer that was pending on this block. + if (m_numPendingTransfers == 0) + { + m_transfersCompletedEvent.Signal(); + } + + m_pendingTransfersMutex.Unlock(); + } + + // ============================================================================================================ + Result ServerBlock::WaitForPendingTransfers(uint32 timeoutInMs) + { + return m_transfersCompletedEvent.Wait(timeoutInMs); + } + + // ============================================================================================================ + Result PullBlock::Read(uint8* pDstBuffer, size_t bufferSize, size_t* pBytesRead) + { + return m_transferClient.ReadPullTransferData(pDstBuffer, bufferSize, pBytesRead); + } + + // ============================================================================================================ + Result PushBlock::Write(const uint8* pDstBuffer, size_t bufferSize) + { + return m_transferClient.WritePushTransferData(pDstBuffer, bufferSize); + } + + // ============================================================================================================ + Result PushBlock::Finalize() + { + return m_transferClient.ClosePushTransfer(false); + } + + // ============================================================================================================ + Result PushBlock::Discard() + { + return m_transferClient.ClosePushTransfer(true); + } + } // TransferProtocol +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/devDriverClient.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/devDriverClient.cpp new file mode 100644 index 000000000..9e3390336 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/devDriverClient.cpp @@ -0,0 +1,181 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file devDriverClient.cpp +* @brief Class definition for DevDriverClient. +*********************************************************************************************************************** +*/ + +#include "devDriverClient.h" +#include "messageChannel.h" +#include "protocolClient.h" +#include "socketMsgTransport.h" +#include "protocols/loggingClient.h" +#include "protocols/settingsClient.h" +#include "protocols/driverControlClient.h" +#include "protocols/rgpClient.h" +#include "protocols/etwClient.h" + +// The local transport implementation is only available on Windows. +#if defined(_WIN32) +#include "win/ddWinPipeMsgTransport.h" +#endif + +namespace DevDriver +{ + DevDriverClient::DevDriverClient(const AllocCb& allocCb, + const ClientCreateInfo& createInfo) + : m_pMsgChannel(nullptr) + , m_pClients(allocCb) + , m_pUnusedClients(allocCb) + , m_allocCb(allocCb) + , m_createInfo(createInfo) + {} + +#if !DD_VERSION_SUPPORTS(GPUOPEN_CREATE_INFO_CLEANUP_VERSION) + DevDriverClient::DevDriverClient(const DevDriverClientCreateInfo& createInfo) + : m_pMsgChannel(nullptr) + , m_pClients(createInfo.transportCreateInfo.allocCb) + , m_pUnusedClients(createInfo.transportCreateInfo.allocCb) + , m_allocCb(createInfo.transportCreateInfo.allocCb) + , m_createInfo() + { + m_createInfo.initialFlags = createInfo.transportCreateInfo.initialFlags; + m_createInfo.componentType = createInfo.transportCreateInfo.componentType; + m_createInfo.createUpdateThread = createInfo.transportCreateInfo.createUpdateThread; + Platform::Strncpy(&m_createInfo.clientDescription[0], + &createInfo.transportCreateInfo.clientDescription[0], + sizeof(m_createInfo.clientDescription)); + switch (createInfo.transportCreateInfo.type) + { + case TransportType::Local: + { + m_createInfo.connectionInfo = kDefaultNamedPipe; + break; + } + case TransportType::Remote: + { + m_createInfo.connectionInfo = createInfo.transportCreateInfo.hostInfo; + // Explicitly overwrite connectionInfo.type since it didn't exist originally. + m_createInfo.connectionInfo.type = createInfo.transportCreateInfo.type; + break; + } + default: + DD_UNREACHABLE(); + break; + } + } +#endif + + DevDriverClient::~DevDriverClient() + { + Destroy(); + } + + Result DevDriverClient::Initialize() + { + Result result = Result::Error; +#if defined(DD_WINDOWS) + if (m_createInfo.connectionInfo.type == TransportType::Local) + { + using MsgChannelPipe = MessageChannel; + m_pMsgChannel = DD_NEW(MsgChannelPipe, m_allocCb)(m_allocCb, + m_createInfo, + m_createInfo.connectionInfo); + } + else if (m_createInfo.connectionInfo.type == TransportType::Remote) + { + using MsgChannelSocket = MessageChannel; + m_pMsgChannel = DD_NEW(MsgChannelSocket, m_allocCb)(m_allocCb, + m_createInfo, + m_createInfo.connectionInfo); + } +#else + if ((m_createInfo.connectionInfo.type == TransportType::Remote) | + (m_createInfo.connectionInfo.type == TransportType::Local)) + { + using MsgChannelSocket = MessageChannel; + m_pMsgChannel = DD_NEW(MsgChannelSocket, m_allocCb)(m_allocCb, + m_createInfo, + m_createInfo.connectionInfo); + } +#endif + else + { + // Invalid transport type + DD_ALERT_REASON("Invalid transport type specified"); + } + + if (m_pMsgChannel != nullptr) + { + result = m_pMsgChannel->Register(kRegistrationTimeoutInMs); + if (result != Result::Success) + { + // We failed to initialize so we need to destroy the message channel. + DD_DELETE(m_pMsgChannel, m_allocCb); + m_pMsgChannel = nullptr; + } + } + + return result; + } + + void DevDriverClient::Destroy() + { + if (m_pMsgChannel != nullptr) + { + Result result = m_pMsgChannel->Unregister(); + DD_ASSERT(result == Result::Success); + DD_UNUSED(result); + + for (auto &pClient : m_pClients) + { + DD_DELETE(pClient, m_allocCb); + } + m_pClients.Clear(); + + for (auto &pClient : m_pUnusedClients) + { + DD_DELETE(pClient, m_allocCb); + } + m_pUnusedClients.Clear(); + + DD_DELETE(m_pMsgChannel, m_allocCb); + m_pMsgChannel = nullptr; + } + } + + bool DevDriverClient::IsConnected() const + { + if (m_pMsgChannel) + return m_pMsgChannel->IsConnected(); + return false; + } + + IMsgChannel* DevDriverClient::GetMessageChannel() const + { + return m_pMsgChannel; + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/devDriverServer.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/devDriverServer.cpp new file mode 100644 index 000000000..a0300babe --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/devDriverServer.cpp @@ -0,0 +1,407 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file devDriverServer.cpp +* @brief Class definition for DevDriverServer. +*********************************************************************************************************************** +*/ + +#include "ddPlatform.h" +#include "messageChannel.h" +#include "devDriverServer.h" +#include "protocolServer.h" +#include "protocols/loggingServer.h" +#include "protocols/settingsServer.h" +#include "protocols/driverControlServer.h" +#include "protocols/rgpServer.h" +#include "protocols/typemap.h" + +// The local transport implementation is only available on Windows. +#if defined(_WIN32) + #include "win/ddWinPipeMsgTransport.h" +#else +#include "socketMsgTransport.h" +#endif + +namespace DevDriver +{ + DevDriverServer::DevDriverServer(const AllocCb& allocCb, + const ServerCreateInfo& createInfo) + : m_pMsgChannel(nullptr) + , m_allocCb(allocCb) + , m_createInfo(createInfo) + { + } + + DevDriverServer::~DevDriverServer() + { + Destroy(); + } + + Result DevDriverServer::Initialize() + { + Result result = Result::Error; + +#if defined(DD_WINDOWS) + if (m_createInfo.connectionInfo.type == TransportType::Local) + { + using MsgChannelPipe = MessageChannel; + m_pMsgChannel = DD_NEW(MsgChannelPipe, m_allocCb)(m_allocCb, + m_createInfo, + m_createInfo.connectionInfo); + } +#else + if (m_createInfo.connectionInfo.type == TransportType::Local) + { + using MsgChannelSocket = MessageChannel; + m_pMsgChannel = DD_NEW(MsgChannelSocket, m_allocCb)(m_allocCb, + m_createInfo, + m_createInfo.connectionInfo); + } +#endif + else + { + // Invalid transport type + DD_ALERT_REASON("Invalid transport type specified"); + } + + if (m_pMsgChannel != nullptr) + { + result = m_pMsgChannel->Register(kInfiniteTimeout); + + if (result == Result::Success) + { + result = InitializeProtocols(); + + if (result != Result::Success) + { + // Unregister the message channel since we failed to initialize the protocols. + m_pMsgChannel->Unregister(); + } + } + + if (result != Result::Success) + { + // We failed to initialize so we need to destroy the message channel. + DD_DELETE(m_pMsgChannel, m_allocCb); + m_pMsgChannel = nullptr; + } + } + return result; + } + + void DevDriverServer::Finalize() + { + // The driver control protocol must always be finalized first! + // It contains the code for supporting the HaltOnStart feature that allows tools to configure + // options before protocol servers are finalized. + if (m_createInfo.servers.driverControl) + { + FinalizeProtocol(Protocol::DriverControl); + } + + if (m_createInfo.servers.logging) + { + FinalizeProtocol(Protocol::Logging); + } + + if (m_createInfo.servers.settings) + { + FinalizeProtocol(Protocol::Settings); + } + + if (m_createInfo.servers.rgp) + { + FinalizeProtocol(Protocol::RGP); + } + } + + void DevDriverServer::Destroy() + { + if (m_pMsgChannel != nullptr) + { + Result result = m_pMsgChannel->Unregister(); + DD_ASSERT(result == Result::Success); + DD_UNUSED(result); + + DestroyProtocols(); + + DD_DELETE(m_pMsgChannel, m_allocCb); + m_pMsgChannel = nullptr; + } + } + + bool DevDriverServer::IsConnected() const + { + if (m_pMsgChannel) + return m_pMsgChannel->IsConnected(); + return false; + } + + IMsgChannel* DevDriverServer::GetMessageChannel() const + { + return m_pMsgChannel; + } + + LoggingProtocol::LoggingServer* DevDriverServer::GetLoggingServer() + { + return GetServer(); + } + + SettingsProtocol::SettingsServer* DevDriverServer::GetSettingsServer() + { + return GetServer(); + } + + DriverControlProtocol::DriverControlServer* DevDriverServer::GetDriverControlServer() + { + return GetServer(); + } + + RGPProtocol::RGPServer* DevDriverServer::GetRGPServer() + { + return GetServer(); + } + + Result DevDriverServer::InitializeProtocols() + { + Result result = Result::Success; + + if (m_createInfo.servers.logging) + { + result = RegisterProtocol(); + } + if (m_createInfo.servers.settings) + { + result = RegisterProtocol(); + } + if (m_createInfo.servers.driverControl) + { + result = RegisterProtocol(); + } + if (m_createInfo.servers.rgp) + { + result = RegisterProtocol(); + } + return result; + } + + void DevDriverServer::DestroyProtocols() + { + if (m_createInfo.servers.logging) + { + UnregisterProtocol(Protocol::Logging); + } + + if (m_createInfo.servers.settings) + { + UnregisterProtocol(Protocol::Settings); + } + + if (m_createInfo.servers.driverControl) + { + UnregisterProtocol(Protocol::DriverControl); + } + + if (m_createInfo.servers.rgp) + { + UnregisterProtocol(Protocol::RGP); + } + } + + Result DevDriverServer::RegisterProtocol(Protocol protocol) + { + Result result = Result::Error; + switch (protocol) + { + case Protocol::Logging: + { + result = RegisterProtocol(); + break; + } + case Protocol::Settings: + { + result = RegisterProtocol(); + break; + } + case Protocol::DriverControl: + { + result = RegisterProtocol(); + break; + } + case Protocol::RGP: + { + result = RegisterProtocol(); + break; + } + default: + { + DD_ALERT_REASON("Invalid protocol specified"); + break; + } + } + return result; + } + + template + Result DevDriverServer::RegisterProtocol(Args... args) + { + Result result = Result::Error; + using T = ProtocolServerType; + T* pProtocolServer = nullptr; + if (m_pMsgChannel->GetProtocolServer(protocol) == nullptr) + { + pProtocolServer = DD_NEW(T, m_allocCb)(m_pMsgChannel, args...); + result = m_pMsgChannel->RegisterProtocolServer(pProtocolServer); + } + return result; + }; + + template + ProtocolServerType* DevDriverServer::GetServer() + { + return static_cast*>(m_pMsgChannel->GetProtocolServer(protocol)); + } + +#if !DD_VERSION_SUPPORTS(GPUOPEN_DISTRIBUTED_STATUS_FLAGS_VERSION) + Result QueryDevDriverStatus(const TransportType type, StatusFlags* pFlags, HostInfo *pHostInfo) + { + Result result = Result::Unavailable; + + // pHostInfo is optional, so we default to local host + const HostInfo& hostInfo = (pHostInfo != nullptr) ? *pHostInfo : kDefaultLocalHost; + +#if defined(_WIN32) + switch (type) + { + case TransportType::Local: + result = WinPipeMsgTransport::QueryStatus(hostInfo, kQueryStatusTimeoutInMs, pFlags); + break; + // QueryDevDriverStatus only works on non-windows platforms for Remote transport types. + } +#else + switch (type) + { + case TransportType::Local: + result = SocketMsgTransport::QueryStatus(hostInfo, kQueryStatusTimeoutInMs, pFlags); + break; + default: + DD_ALERT_REASON("Invalid transport type specified"); + break; + } +#endif + return result; + } +#endif + + bool DevDriverServer::IsConnectionAvailable(const HostInfo& hostInfo, + uint32 timeout) + { + // At this time, we only support machine local connections for the driver + Result result = Result::Unavailable; + switch (hostInfo.type) + { + case TransportType::Local: +#if !defined(_WIN32) + // On non windows platforms we try to use an AF_UNIX socket for communication + result = SocketMsgTransport::TestConnection(hostInfo, timeout); +#else + // Winsock doesn't support AF_UNIX style sockets, so we use a custom named pipe transport instead + result = WinPipeMsgTransport::TestConnection(hostInfo, timeout); +#endif + break; + default: + // Invalid value passed to the function + DD_ALERT_REASON("Invalid transport type specified"); + break; + } + return (result == Result::Success); + } + + void DevDriverServer::UnregisterProtocol(Protocol protocol) + { + IProtocolServer *pProtocolServer = m_pMsgChannel->GetProtocolServer(protocol); + if (pProtocolServer != nullptr) + { + const Result result = m_pMsgChannel->UnregisterProtocolServer(pProtocolServer); + DD_ASSERT(result == Result::Success); + DD_UNUSED(result); + DD_DELETE(pProtocolServer, m_allocCb); + } + } + + void DevDriverServer::FinalizeProtocol(Protocol protocol) + { + IProtocolServer *pProtocolServer = m_pMsgChannel->GetProtocolServer(protocol); + DD_ASSERT(pProtocolServer != nullptr); + + pProtocolServer->Finalize(); + } + +#if !DD_VERSION_SUPPORTS(GPUOPEN_CREATE_INFO_CLEANUP_VERSION) + DevDriverServer::DevDriverServer(const DevDriverServerCreateInfo& createInfo) + : m_pMsgChannel(nullptr) + , m_allocCb(createInfo.transportCreateInfo.allocCb) + , m_createInfo() + { + m_createInfo.initialFlags = createInfo.transportCreateInfo.initialFlags; + m_createInfo.componentType = createInfo.transportCreateInfo.componentType; + m_createInfo.createUpdateThread = createInfo.transportCreateInfo.createUpdateThread; + Platform::Strncpy(&m_createInfo.clientDescription[0], + &createInfo.transportCreateInfo.clientDescription[0], + sizeof(m_createInfo.clientDescription)); + switch (createInfo.transportCreateInfo.type) + { + case TransportType::Local: + { + m_createInfo.connectionInfo = kDefaultNamedPipe; + break; + } + default: + DD_ALERT_REASON("Invalid transport type specified"); + break; + } + m_createInfo.servers = createInfo.enabledProtocols; + } + + bool DevDriverServer::IsConnectionAvailable(const TransportType type, + uint32 timeout) + { + bool result = false; + switch (type) + { + case TransportType::Local: + // On non windows platforms we try to use an AF_UNIX socket for communication + result = IsConnectionAvailable(kDefaultNamedPipe, timeout); + break; + default: + // Invalid value passed to the function + DD_ALERT_REASON("Invalid transport type specified"); + break; + } + return result; + } +#endif +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/messageChannel.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/messageChannel.h new file mode 100644 index 000000000..98c1708c3 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/messageChannel.h @@ -0,0 +1,235 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file messageChannel.h +* @brief Class declaration for BaseMsgChannel +*********************************************************************************************************************** +*/ + +#pragma once + +#include "msgChannel.h" +#include "msgTransport.h" +#include "sessionManager.h" +#include "util/queue.h" +#include "ddPlatform.h" +#include "protocols/systemProtocols.h" +#include "ddTransferManager.h" +#include "protocols/ddURIServer.h" +#include "ddClientURIService.h" + +namespace DevDriver +{ + template + class MessageChannel : public IMsgChannel + { + static void MsgChannelReceiveFunc(void* pThreadParam); + DD_STATIC_CONST uint32 kMaxBufferedMessages = 64; + + public: + template + + MessageChannel(const AllocCb& allocCb, + const MessageChannelCreateInfo& createInfo, + Args&&... args); + + ~MessageChannel(); + + void Update(uint32 timeoutInMs = kDefaultUpdateTimeoutInMs) override final; + + Result Register(uint32 timeoutInMs = kInfiniteTimeout) override final; + Result Unregister() override final; + bool IsConnected() override final; + + Result SetStatusFlags(StatusFlags flags) override final; + StatusFlags GetStatusFlags() const override final; + + Result Send(ClientId dstClientId, + Protocol protocol, + MessageCode message, + const ClientMetadata& metadata, + uint32 payloadSizeInBytes, + const void* pPayload) override final; + + Result Receive(MessageBuffer& message, uint32 timeoutInMs) override final; + Result Forward(const MessageBuffer& messageBuffer) override final; + + Result ConnectProtocolClient(IProtocolClient* pProtocolClient, ClientId dstClientId) override final; + Result RegisterProtocolServer(IProtocolServer* pServer) override final; + Result UnregisterProtocolServer(IProtocolServer* pServer) override final; + IProtocolServer* GetProtocolServer(Protocol protocol) override final; + + ClientId GetClientId() const override final; + + const ClientInfoStruct& GetClientInfo() const override final + { + return m_clientInfoResponse; + } + + const char* GetTransportName() const override + { + return m_msgTransport.GetTransportName(); + } + + Result FindFirstClient(const ClientMetadata& filter, + ClientId* pClientId, + uint32 timeoutInMs, + ClientMetadata* pClientMetadata) override final; + + const AllocCb& GetAllocCb() const override final + { + return m_allocCb; + } + + TransferProtocol::TransferManager& GetTransferManager() override final + { + return m_transferManager; + } + + Result RegisterService(IService* pService) override final + { + DD_ASSERT(pService != nullptr); + DD_ASSERT(m_pURIServer != nullptr); + + return m_pURIServer->RegisterService(pService); + } + + Result UnregisterService(IService* pService) override final + { + DD_ASSERT(pService != nullptr); + DD_ASSERT(m_pURIServer != nullptr); + + return m_pURIServer->UnregisterService(pService); + } + + protected: + struct MsgThreadInfo + { + volatile bool active; + }; + + struct ReceiveQueue + { + Queue queue; + Platform::Semaphore semaphore; + Platform::AtomicLock lock; + + explicit ReceiveQueue(const AllocCb& allocCb) + : queue(allocCb) + , semaphore(0, kMaxBufferedMessages) {} + }; + + Result CreateMsgThread(); + Result DestroyMsgThread(); + + Result Disconnect(); + bool HandleMessageReceived(const MessageBuffer& messageBuffer); + + Result SendSystem(ClientId dstClientId, SystemProtocol::SystemMessage message, const ClientMetadata& metadata); + +#ifdef DEVDRIVER_ENABLE_PACKET_LOSS + // Returns true if a packet should be dropped. Used for testing. + bool ShouldDropPacket() + { + // Generate a random value between 0.0 and 1.0. + const float dropValue = (static_cast(m_packetLossRng.Generate()) / + static_cast(m_packetLossRng.Max())); + + // Return true to drop the packet if the random value is below the packet loss ratio/threshold. + return (dropValue < static_cast(DEVDRIVER_PACKET_LOSS_RATIO)); + } + + // Write a message into the internal transport + Result WriteTransportMessage(const MessageBuffer& messageBuffer) + { + // If we're testing packet loss and we want to drop a packet, return Success without + // actually writing the message into the transport. + if (ShouldDropPacket()) + { + return Result::Success; + } + + return m_msgTransport.WriteMessage(messageBuffer); + } + + // Reads a message from the internal transport + Result ReadTransportMessage(MessageBuffer& messageBuffer, uint32 timeoutInMs) + { + Result result = m_msgTransport.ReadMessage(messageBuffer, timeoutInMs); + + // If we're testing packet loss and we want to drop a packet, read the message out of the + // transport but tell the caller that we didn't get anything. + if ((result == Result::Success) && ShouldDropPacket()) + { + result = Result::NotReady; + } + + return result; + } +#else + // Write a message into the internal transport + Result WriteTransportMessage(const MessageBuffer& messageBuffer) + { + return m_msgTransport.WriteMessage(messageBuffer); + } + + // Reads a message from the internal transport + Result ReadTransportMessage(MessageBuffer& messageBuffer, uint32 timeoutInMs) + { + return m_msgTransport.ReadMessage(messageBuffer, timeoutInMs); + } +#endif + + DD_STATIC_CONST uint64 kKeepAliveTimeout = 2000; + DD_STATIC_CONST uint64 kKeepAliveThreshold = 5; + DD_STATIC_CONST uint64 kRetransmitTimeoutInMs = 50; + + MsgTransport m_msgTransport; + ReceiveQueue m_receiveQueue; + ClientId m_clientId; + + AllocCb m_allocCb; + const MessageChannelCreateInfo m_createInfo; + ClientInfoStruct m_clientInfoResponse; +#ifdef DEVDRIVER_ENABLE_PACKET_LOSS + // Random number generator for packet loss testing. + Platform::Random m_packetLossRng; +#endif + + volatile uint64 m_lastActivityTimeMs; + SessionId m_lastKeepaliveTransmitted; + SessionId m_lastKeepaliveReceived; + + Platform::Thread m_msgThread; + MsgThreadInfo m_msgThreadParams; + Platform::Semaphore m_updateSemaphore; + SessionManager m_sessionManager; + TransferProtocol::TransferManager m_transferManager; + URIProtocol::URIServer* m_pURIServer; + ClientURIService m_clientURIService; + }; + +} // DevDriver +#include "messageChannel.inl" diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/messageChannel.inl b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/messageChannel.inl new file mode 100644 index 000000000..027fc2edf --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/messageChannel.inl @@ -0,0 +1,788 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "messageChannel.h" +#include "protocolServer.h" +#include "protocolClient.h" + +namespace DevDriver +{ + //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + // Thread function that calls the message channel update function until the + template + void MessageChannel::MsgChannelReceiveFunc(void* pThreadParam) + { + MessageChannel* pMessageChannel = reinterpret_cast(pThreadParam); + + while ((pMessageChannel->m_msgThreadParams.active) & (pMessageChannel->m_clientId != kBroadcastClientId)) + { + pMessageChannel->Update(); + } + + // Check to see if the message thread was terminated normally. If active is still set to true we are destroying + // this thread due to a connection failure, so we need to close all active sessions and exit. + if (pMessageChannel->m_msgThreadParams.active) + { + const Result status = pMessageChannel->m_sessionManager.Destroy(); + DD_ASSERT(status == Result::Success); + DD_UNUSED(status); + pMessageChannel->m_msgThreadParams.active = false; + } + } + + template + template + MessageChannel::MessageChannel(const AllocCb& allocCb, + const MessageChannelCreateInfo& createInfo, + Args&&... args) : + m_msgTransport(Platform::Forward(args)...), + m_receiveQueue(allocCb), + m_clientId(kBroadcastClientId), + m_allocCb(allocCb), + m_createInfo(createInfo), + m_clientInfoResponse(), + m_lastActivityTimeMs(0), + m_lastKeepaliveTransmitted(0), + m_lastKeepaliveReceived(0), + m_msgThread(), + m_msgThreadParams(), + m_updateSemaphore(1, 1), + m_sessionManager(allocCb), + m_transferManager(allocCb), + m_pURIServer(nullptr), + m_clientURIService() + { + } + + template + MessageChannel::~MessageChannel() + { + Unregister(); + } + + template + void MessageChannel::Update(uint32 timeoutInMs) + { + MessageBuffer messageBuffer = {}; + + // Attempt to read a message from the queue with a timeout. + if (m_updateSemaphore.Wait(kInfiniteTimeout) == Result::Success) + { + Result status = ReadTransportMessage(messageBuffer, timeoutInMs); + while (status == Result::Success) + { + // Read any remaining messages in the queue without waiting on a timeout until the queue is empty. + if (!HandleMessageReceived(messageBuffer)) + { + Platform::LockGuard lock(m_receiveQueue.lock); + if (m_receiveQueue.queue.PushBack(messageBuffer)) + { + m_receiveQueue.semaphore.Signal(); + } + } + status = ReadTransportMessage(messageBuffer, kNoWait); + } + + if (status != Result::NotReady) + { + Disconnect(); + } + else if (MsgTransport::RequiresClientRegistration() & MsgTransport::RequiresKeepAlive()) + { + // if keep alive is enabled and the last message read wasn't an error + uint64 currentTime = Platform::GetCurrentTimeInMs(); + + // only check the keep alive threshold if we haven't had any network traffic in kKeepAliveTimeout time + if ((currentTime - m_lastActivityTimeMs) > kKeepAliveTimeout) + { + // if we have gone heartbeats without reponse we disconnect + if ((m_lastKeepaliveTransmitted - m_lastKeepaliveReceived) < kKeepAliveThreshold) + { + // send a heartbeat and increment the last keepalive transmitted variable + using namespace DevDriver::ClientManagementProtocol; + MessageBuffer heartbeat = kOutOfBandMessage; + heartbeat.header.messageId = static_cast(ManagementMessage::KeepAlive); + heartbeat.header.sessionId = ++m_lastKeepaliveTransmitted; + Forward(heartbeat); + + // we need to update the last activity time to make sure it doesn't immediately timeout again + m_lastActivityTimeMs = currentTime; + } + else + { + // we have sent too many heartbeats without response, so disconnect + Disconnect(); + } + } + } + + // Give the session manager a chance to update its sessions. + m_sessionManager.UpdateSessions(); + + m_updateSemaphore.Signal(); + +#if defined(DD_LINUX) + // we yield the thread after processing messages to let other threads grab the lock if the need to + // this works around an issue where the message processing thread releases the lock then reacquires + // it before a sleeping thread that is waiting on it can get it. + Platform::Sleep(0); +#endif + } + } + + template + Result MessageChannel::ConnectProtocolClient(IProtocolClient* pClient, ClientId dstClientId) + { + return (pClient != nullptr) ? m_sessionManager.EstablishSessionForClient(*pClient, dstClientId) : Result::Error; + } + + template + Result MessageChannel::RegisterProtocolServer(IProtocolServer* pServer) + { + Result result = Result::Error; + if (pServer != nullptr) + { + ProtocolFlags enabledProtocols = {}; + switch (pServer->GetProtocol()) + { + case Protocol::Logging: + { + enabledProtocols.logging = true; + break; + } + + case Protocol::Settings: + { + enabledProtocols.settings = true; + break; + } + + case Protocol::DriverControl: + { + enabledProtocols.driverControl = true; + break; + } + + case Protocol::RGP: + { + enabledProtocols.rgp = true; + break; + } + + case Protocol::ETW: + { + enabledProtocols.etw = true; + break; + } + + case Protocol::GpuCrashDump: + { + enabledProtocols.gpuCrashDump = true; + break; + } + + default: + { + DD_ALERT_REASON("Registered protocol server for unknown protocol"); + break; + } + } + + result = m_sessionManager.RegisterProtocolServer(pServer); + if (result == Result::Success) + { + m_clientInfoResponse.metadata.protocols.value |= enabledProtocols.value; + } + } + return result; + } + + template + Result MessageChannel::UnregisterProtocolServer(IProtocolServer* pServer) + { + // @todo: Remove enabled protocol metadata flags related to pServer + + return m_sessionManager.UnregisterProtocolServer(pServer); + } + + template + ClientId MessageChannel::GetClientId() const + { + return m_clientId; + } + + template + inline Result MessageChannel::FindFirstClient(const ClientMetadata& filter, + ClientId* pClientId, + uint32 timeoutInMs, + ClientMetadata* pClientMetadata) + { + using namespace DevDriver::SystemProtocol; + Result result = Result::Error; + + if (pClientId != nullptr) + { + result = Result::NotReady; + // acquire the update semaphore. this prevents the update thread from processing messages + // as it is possible it could process messages the client was looking for + if (m_updateSemaphore.Wait(kInfiniteTimeout) == Result::Success) + { + const uint64 startTime = Platform::GetCurrentTimeInMs(); + uint64 timeDelta = 0; + + MessageBuffer messageBuffer = {}; + + // we're going to loop through sending a ping, receiving/processing any messages, then updating sessions + do + { + // send a ping every time the outer loop executes + result = SendSystem(kBroadcastClientId, + SystemMessage::Ping, + filter); + + // there are two expected results from SendSystem: Success or NotReady + // if it is successful, we need to transition to waiting + if (result == Result::Success) + { + // read any traffic waiting + result = ReadTransportMessage(messageBuffer, kDefaultUpdateTimeoutInMs); + + // we are going to loop until either an error is encountered or there is no data remaining + // the expected behavior is that this loop will exit with result == Result::NotReady + while (result == Result::Success) + { + // if the default message handler doesn't care about this message we inspect it + if (!HandleMessageReceived(messageBuffer)) + { + // did we receive any pong messages? + if ((messageBuffer.header.protocolId == Protocol::System) & + (static_cast(messageBuffer.header.messageId) == SystemMessage::Pong)) + { + const ClientMetadata metadata = + *reinterpret_cast(&messageBuffer.header.sequence); + // check to see if it matches with our initial filter + if (filter.Matches(metadata)) + { + // if it does, write out the client ID + *pClientId = messageBuffer.header.srcClientId; + + // If the pClientMetadata pointer is valid, fill it with the matching client + // metadata struct data. + if (pClientMetadata != nullptr) + { + pClientMetadata->value = metadata.value; + } + + // if we found a matching client we break out of the inner loop. + // the outer loop will exit automatically because result is implied to be Success + // inside the execution of this loop + break; + } + } + else + { + // if this message wasn't one we were looking for, we go ahead and enqueue + // the message in the local receive queue + Platform::LockGuard lock(m_receiveQueue.lock); + if (m_receiveQueue.queue.PushBack(messageBuffer)) + { + m_receiveQueue.semaphore.Signal(); + } + } + } + + // read the next message with no timeout + // this ensures that this inner loop will exit immediately when no data is remaining + result = ReadTransportMessage(messageBuffer, kNoWait); + } + + // Give the session manager a chance to update its sessions. + m_sessionManager.UpdateSessions(); + } + else if (result == Result::NotReady) + { + // the write failed because the transport was busy, so we sleep and will try again + Platform::Sleep(Platform::Min(timeoutInMs, kDefaultUpdateTimeoutInMs)); + } + + // calculate how much time has elapsed since we started looping + timeDelta = Platform::GetCurrentTimeInMs() - startTime; + + // we repeat this loop so long as: + // 1. result is NotReady, which implies that either the write or last read timed out + // 2. The loop haven't exceed the specified timeout + // we exit the outer loop if: + // 1. The inner loop exited with result equal to Success, indicating we found a client + // 2. result indicates an unexpected error + // 3. We have timed out, in which case result is already NotReady + } while ((result == Result::NotReady) & + (timeDelta < timeoutInMs)); + + // release the update lock + m_updateSemaphore.Signal(); + } + } + return result; + } + + template + bool MessageChannel::HandleMessageReceived(const MessageBuffer& messageBuffer) + { + using namespace DevDriver::SystemProtocol; + using namespace DevDriver::ClientManagementProtocol; + + bool handled = false; + bool forThisHost = false; + + // todo: move this out into message reading loop so that it isn't getting done for every message + if (MsgTransport::RequiresClientRegistration() & MsgTransport::RequiresKeepAlive()) + { + m_lastActivityTimeMs = Platform::GetCurrentTimeInMs(); + } + + if ((messageBuffer.header.protocolId == Protocol::Session) & (messageBuffer.header.dstClientId == m_clientId)) + { + m_sessionManager.HandleReceivedSessionMessage(messageBuffer); + handled = true; + } + else if (IsOutOfBandMessage(messageBuffer)) + { + handled = true; // always filter these out from the client + if (IsValidOutOfBandMessage(messageBuffer) + & (static_cast(messageBuffer.header.messageId) == ManagementMessage::KeepAlive)) + { + DD_PRINT(LogLevel::Debug, "Received keep alive response seq %u", messageBuffer.header.sessionId); + m_lastKeepaliveReceived = messageBuffer.header.sessionId; + } + } + else + { + using namespace DevDriver::SystemProtocol; + const ClientId &dstClientId = messageBuffer.header.dstClientId; + const ClientMetadata *pMetadata = reinterpret_cast(&messageBuffer.header.sequence); + forThisHost = !!((((dstClientId == kBroadcastClientId) + & (pMetadata->Matches(m_clientInfoResponse.metadata))) + | ((m_clientId != kBroadcastClientId) & (dstClientId == m_clientId)))); + if ((forThisHost) & (messageBuffer.header.protocolId == Protocol::System)) + { + const ClientId &srcClientId = messageBuffer.header.srcClientId; + + const SystemMessage& message = static_cast(messageBuffer.header.messageId); + + switch (message) + { + case SystemMessage::Ping: + { + SendSystem(srcClientId, + SystemMessage::Pong, + m_clientInfoResponse.metadata); + + handled = true; + + break; + } + case SystemMessage::QueryClientInfo: + { + Send(srcClientId, + Protocol::System, + static_cast(SystemMessage::ClientInfo), + m_clientInfoResponse.metadata, + sizeof(m_clientInfoResponse), + &m_clientInfoResponse); + + handled = true; + + break; + } + case SystemMessage::ClientDisconnected: + { + m_sessionManager.HandleClientDisconnection(srcClientId); + break; + } + default: + { + // Unhandled system message + break; + } + } + } + } + return (handled | (!forThisHost)); + } + + template + Result MessageChannel::Send(ClientId dstClientId, Protocol protocol, MessageCode message, const ClientMetadata &metadata, uint32 payloadSizeInBytes, const void* pPayload) + { + MessageBuffer messageBuffer = {}; + messageBuffer.header.dstClientId = dstClientId; + messageBuffer.header.srcClientId = m_clientId; + messageBuffer.header.protocolId = protocol; + messageBuffer.header.messageId = message; + messageBuffer.header.payloadSize = payloadSizeInBytes; + messageBuffer.header.sequence = metadata.value; + + if ((pPayload != nullptr) & (payloadSizeInBytes != 0)) + { + memcpy(messageBuffer.payload, pPayload, Platform::Min(payloadSizeInBytes, static_cast(sizeof(messageBuffer.payload)))); + } + return Forward(messageBuffer); + } + + template + Result MessageChannel::SendSystem(ClientId dstClientId, SystemProtocol::SystemMessage message, const ClientMetadata &metadata) + { + MessageBuffer messageBuffer = {}; + messageBuffer.header.dstClientId = dstClientId; + messageBuffer.header.srcClientId = m_clientId; + messageBuffer.header.protocolId = Protocol::System; + messageBuffer.header.messageId = static_cast(message); + messageBuffer.header.sequence = metadata.value; + return Forward(messageBuffer); + } + + template + Result MessageChannel::Forward(const MessageBuffer& messageBuffer) + { + Result result = Result::Error; + if (m_clientId != kBroadcastClientId) + { + result = WriteTransportMessage(messageBuffer); + if ((result != Result::Success) & (result != Result::NotReady)) + { + Disconnect(); + } + } + return result; + } + + template + Result MessageChannel::Receive(MessageBuffer& message, uint32 timeoutInMs) + { + Result result = Result::Unavailable; + if ((m_receiveQueue.queue.Size() > 0) | (m_clientId != kBroadcastClientId)) + { + result = m_receiveQueue.semaphore.Wait(timeoutInMs); + if (result == Result::Success) + { + Platform::LockGuard lock(m_receiveQueue.lock); + m_receiveQueue.queue.PopFront(message); + } + } + return result; + } + + template + Result MessageChannel::Register(uint32 timeoutInMs) + { + Result status = Result::Error; + + if (m_clientId == kBroadcastClientId) + { + status = m_msgTransport.Connect(&m_clientId, timeoutInMs); + } + + if (MsgTransport::RequiresClientRegistration()) + { + if ((status == Result::Success) & (m_clientId == kBroadcastClientId)) + { + using namespace DevDriver::ClientManagementProtocol; + MessageBuffer recvBuffer = {}; + MessageBuffer messageBuffer = kOutOfBandMessage; + messageBuffer.header.messageId = static_cast(ManagementMessage::ConnectRequest); + messageBuffer.header.payloadSize = sizeof(ConnectRequestPayload); + + { + ConnectRequestPayload* DD_RESTRICT pConnectionRequest = + reinterpret_cast(&messageBuffer.payload[0]); + pConnectionRequest->componentType = m_createInfo.componentType; + pConnectionRequest->initialClientFlags = m_createInfo.initialFlags; + } + + uint64 sendTime = Platform::GetCurrentTimeInMs(); + uint64 currentTime = sendTime; + + Result registerResult; + do + { + registerResult = WriteTransportMessage(messageBuffer); + + if (registerResult == Result::Success) + { + registerResult = ReadTransportMessage(recvBuffer, kRetransmitTimeoutInMs); + if (registerResult == Result::Success) + { + registerResult = Result::NotReady; + if (recvBuffer.header.protocolId == Protocol::ClientManagement) + { + registerResult = Result::VersionMismatch; + if (IsOutOfBandMessage(recvBuffer) & + IsValidOutOfBandMessage(recvBuffer) & + (static_cast(recvBuffer.header.messageId) == ManagementMessage::ConnectResponse)) + { + ConnectResponsePayload* DD_RESTRICT pConnectionResponse = + reinterpret_cast(&recvBuffer.payload[0]); + registerResult = pConnectionResponse->result; + m_clientId = pConnectionResponse->clientId; + } + } + } + } + + currentTime = Platform::GetCurrentTimeInMs(); + } while ((registerResult == Result::NotReady) & ((currentTime - sendTime) < timeoutInMs)); + + status = registerResult; + } + } + if (status == Result::Success) + { + memset(&m_clientInfoResponse, 0, sizeof(m_clientInfoResponse)); + Platform::Strncpy(m_clientInfoResponse.clientDescription, m_createInfo.clientDescription, sizeof(m_clientInfoResponse.clientDescription)); + Platform::GetProcessName(m_clientInfoResponse.clientName, sizeof(m_clientInfoResponse.clientName)); + m_clientInfoResponse.processId = Platform::GetProcessId(); + m_clientInfoResponse.metadata.clientType = m_createInfo.componentType; + m_clientInfoResponse.metadata.status = m_createInfo.initialFlags; + + status = ((m_sessionManager.Init(this) == Result::Success) ? Result::Success : Result::Error); + + // Initialize the transfer manager + if (status == Result::Success) + { + status = ((m_transferManager.Init(this, &m_sessionManager) == Result::Success) ? Result::Success : Result::Error); + } + + // Initialize the URI server + if (status == Result::Success) + { + m_pURIServer = DD_NEW(URIProtocol::URIServer, m_allocCb)(this); + status = (m_pURIServer != nullptr) ? Result::Success : Result::Error; + } + + // Register the URI server + if (status == Result::Success) + { + m_sessionManager.RegisterProtocolServer(m_pURIServer); + } + + // Set up internal URI services + if (status == Result::Success) + { + m_clientURIService.BindMessageChannel(this); + m_pURIServer->RegisterService(&m_clientURIService); + } + + if ((status == Result::Success) & m_createInfo.createUpdateThread) + { + status = CreateMsgThread(); + } + } + return status; + } + + template + Result MessageChannel::Unregister() + { + if (m_createInfo.createUpdateThread) + { + Result status = DestroyMsgThread(); + DD_ASSERT(status == Result::Success); + DD_UNUSED(status); + } + + if (m_pURIServer != nullptr) + { + m_sessionManager.UnregisterProtocolServer(m_pURIServer); + + DD_DELETE(m_pURIServer, m_allocCb); + m_pURIServer = nullptr; + } + + // Destroy the transfer manager + m_transferManager.Destroy(); + + Result status = m_sessionManager.Destroy(); + DD_ASSERT(status == Result::Success); + DD_UNUSED(status); + + if (MsgTransport::RequiresClientRegistration()) + { + if (m_clientId != kBroadcastClientId) + { + using namespace DevDriver::ClientManagementProtocol; + MessageBuffer disconnectMsgBuffer = {}; + disconnectMsgBuffer.header.protocolId = Protocol::ClientManagement; + disconnectMsgBuffer.header.messageId = + static_cast(ManagementMessage::DisconnectNotification); + disconnectMsgBuffer.header.srcClientId = m_clientId; + disconnectMsgBuffer.header.dstClientId = kBroadcastClientId; + disconnectMsgBuffer.header.payloadSize = 0; + + WriteTransportMessage(disconnectMsgBuffer); + } + } + return Disconnect(); + } + + template + inline bool MessageChannel::IsConnected() + { + return (m_clientId != kBroadcastClientId); + } + + template + Result MessageChannel::SetStatusFlags(StatusFlags flags) + { + Result status = Result::Error; + if (m_clientId != kBroadcastClientId) + { +#if DD_VERSION_SUPPORTS(GPUOPEN_DISTRIBUTED_STATUS_FLAGS_VERSION) + m_clientInfoResponse.metadata.status = flags; + status = Result::Success; +#else + status = m_msgTransport.UpdateClientStatus(m_clientId, flags); + + if (status == Result::Unavailable) + { + status = m_updateSemaphore.Wait(kInfiniteTimeout); + if (status == Result::Success) + { + using namespace DevDriver::ClientManagementProtocol; + // @todo: Implement support for updating client status in SocketMsgTransport + MessageBuffer updateMsgBuffer = {}; + MessageBuffer recvBuffer = {}; + + updateMsgBuffer.header.protocolId = Protocol::ClientManagement; + updateMsgBuffer.header.messageId = static_cast(ManagementMessage::SetClientFlags); + updateMsgBuffer.header.srcClientId = m_clientId; + updateMsgBuffer.header.dstClientId = kBroadcastClientId; + updateMsgBuffer.header.payloadSize = sizeof(SetClientFlagsPayload); + + { + SetClientFlagsPayload* DD_RESTRICT pRequest = reinterpret_cast(updateMsgBuffer.payload); + pRequest->flags = flags; + } + + do + { + status = Forward(updateMsgBuffer); + if (status == Result::Success) + { + status = ReadTransportMessage(recvBuffer, kDefaultUpdateTimeoutInMs); + while (status == Result::Success) + { + if (!HandleMessageReceived(recvBuffer)) + { + if ((recvBuffer.header.protocolId == Protocol::ClientManagement) & + (static_cast(recvBuffer.header.messageId) == ManagementMessage::SetClientFlagsResponse)) + { + SetClientFlagsResponsePayload* DD_RESTRICT pResponse = + reinterpret_cast(recvBuffer.payload); + DD_ASSERT(pResponse->result != Result::NotReady); + status = pResponse->result; + break; // break out of inner while loop + } + else + { + Platform::LockGuard lock(m_receiveQueue.lock); + if (m_receiveQueue.queue.PushBack(recvBuffer)) + { + m_receiveQueue.semaphore.Signal(); + } + } + status = ReadTransportMessage(recvBuffer, 0); + } + + // Give the session manager a chance to update its sessions. + m_sessionManager.UpdateSessions(); + } + } + } while (status == Result::NotReady); + m_updateSemaphore.Signal(); + } + } + if (status == Result::Success) + { + m_clientInfoResponse.metadata.status = flags; + } +#endif + } + return status; + } + + template + StatusFlags MessageChannel::GetStatusFlags() const + { + return m_clientInfoResponse.metadata.status; + } + + template + Result MessageChannel::CreateMsgThread() + { + memset(&m_msgThreadParams, 0, sizeof(m_msgThreadParams)); + + m_msgThreadParams.active = true; + + Result result = m_msgThread.Start(MsgChannelReceiveFunc, this); + + if (result != Result::Success) + { + m_msgThreadParams.active = false; + DD_ALERT_REASON("Thread creation failed"); + } + + return DD_SANITIZE_RESULT(result); + } + + template + Result MessageChannel::DestroyMsgThread() + { + Result result = Result::Success; + if (m_msgThread.IsJoinable()) + { + m_msgThreadParams.active = false; + result = m_msgThread.Join(); + } + return DD_SANITIZE_RESULT(result); + } + + template + inline Result MessageChannel::Disconnect() + { + Result result = Result::Success; + if (m_clientId != kBroadcastClientId) + { + m_clientId = kBroadcastClientId; + m_msgTransport.Disconnect(); + result = Result::Success; + } + return result; + } + + template + IProtocolServer *MessageChannel::GetProtocolServer(Protocol protocol) + { + return m_sessionManager.GetProtocolServer(protocol); + } + +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/netMsgTransport.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/netMsgTransport.h new file mode 100644 index 000000000..d727d70e2 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/netMsgTransport.h @@ -0,0 +1,68 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file socketMsgTransport.h +* @brief Class declaration for SocketMsgTransport +*********************************************************************************************************************** +*/ + +#pragma once + +#include "msgTransport.h" +#include "ddSocket.h" + +namespace DevDriver +{ + class NetworkMsgTransport : IMsgTransport + { + public: + NetworkMsgTransport(const TransportCreateInfo& createInfo); + ~NetworkMsgTransport(); + + Result Connect(ClientId* pClientId, uint32 timeoutInMs) override; + Result Disconnect() override; + + Result ReadMessage(MessageBuffer &messageBuffer, uint32 timeoutInMs) override; + Result WriteMessage(const MessageBuffer &messageBuffer) override; + +#if GPUOPEN_CLIENT_INTERFACE_MAJOR_VERSION < GPUOPEN_CLIENT_REGISTRATION_VERSION + Result RegisterExternalClient(Component componentType, ClientId* pExternalClientId) override + { + return RegisterExternalClient(componentType, 0, pExternalClientId); + }; +#endif + Result RegisterExternalClient(Component componentType, ClientFlags flags, ClientId* pExternalClientId) override; + Result UnregisterExternalClient(ClientId externalClientId) override; + Result UpdateClientStatus(ClientId clientId, ClientFlags flags) override; + + static Result QueryStatus(TransportType type, ClientFlags *pFlags, uint32 timeoutInMs); + + private: + Component m_componentType; + ClientFlags m_initialClientFlags; + ClientId m_clientId; + }; + +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/posix/ddPosixPlatform.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/posix/ddPosixPlatform.cpp new file mode 100644 index 000000000..79e39d5d7 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/posix/ddPosixPlatform.cpp @@ -0,0 +1,467 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file ddPosixPlatform.cpp +* @brief POSIX platform layer implementation +*********************************************************************************************************************** +*/ + +#include "ddPlatform.h" + +#include +#include +#include +#include +#include +#include + +// Make sure our timeout definition matches the Windows value. +static_assert(DevDriver::kInfiniteTimeout == ~(0u), "Infinite Timeout value does not match OS definition!"); + +namespace DevDriver +{ + namespace Platform + { + static Result GetAbsTime(uint32 offsetInMs, timespec *pOutput) + { + Result result = Result::Error; + timespec timeValue = {}; + if (clock_gettime(CLOCK_REALTIME, &timeValue) == 0) + { + const uint64 timeInMs = (static_cast(timeValue.tv_sec) * 1000) + + (static_cast(timeValue.tv_nsec) / 1000000) + offsetInMs; + const uint64 sec = timeInMs / 1000; + const uint64 nsec = (timeInMs - (sec * 1000)) * 1000000; + pOutput->tv_sec = static_cast(sec); + pOutput->tv_nsec = static_cast(nsec); + result = Result::Success; + } + return result; + } + + ///////////////////////////////////////////////////// + // Local routines..... + // + void DebugPrint(LogLevel lvl, const char* format, ...) + { + va_list args; + va_start(args, format); + char buffer[1024]; + vsnprintf(buffer,sizeof(buffer), format, args); + va_end(args); + +#ifdef DEVDRIVER_PRINT_TO_CONSOLE + printf("%s\n", buffer); +#endif + + } + + int32 AtomicIncrement(Atomic *variable) + { + return __sync_add_and_fetch(variable, 1); + } + + int32 AtomicDecrement(Atomic *variable) + { + return __sync_sub_and_fetch(variable, 1); + } + + int32 AtomicAdd(Atomic *variable, int32 num) + { + return __sync_add_and_fetch(variable, num); + } + + int32 AtomicSubtract(Atomic *variable, int32 num) + { + return __sync_sub_and_fetch(variable, num); + } + + ///////////////////////////////////////////////////// + // Thread routines..... + // + + void* PlatformThreadShim(void *pThreadParam) + { + DD_ASSERT(pThreadParam != nullptr); + const ThreadStorage *thread = reinterpret_cast(pThreadParam); + thread->callback(thread->parameter); + return nullptr; + } + + Thread::Thread() : m_thread() {}; + + Thread::~Thread() {}; + + Result Thread::Start(void(*threadCallback)(void *), void *threadParameter) + { + DD_ASSERT(threadCallback != nullptr); + + Result result = Result::Error; + + if (m_thread.callback == nullptr) + { + m_thread.parameter = threadParameter; + m_thread.callback = threadCallback; + + if (pthread_create(&m_thread.handle, nullptr, &PlatformThreadShim, &m_thread) == 0) + { + result = Result::Success; + } + else + { + memset(&m_thread, 0, sizeof(ThreadStorage)); + } + + DD_ALERT(result != Result::Error); + } + return result; + } + + Result Thread::Join() + { + DD_ASSERT(m_thread.callback != nullptr); + + Result result = Result::Error; + + if (pthread_join(m_thread.handle, nullptr) == 0) + { + memset(&m_thread, 0, sizeof(ThreadStorage)); + result = Result::Success; + } + + DD_ALERT(result != Result::Error); + return result; + } + + bool Thread::IsJoinable() const + { + return m_thread.callback != nullptr; + } + + ///////////////////////////////////////////////////// + // Memory Management + ///////////////////////////////////////////////////// + + void* AllocateMemory(size_t size, size_t alignment, bool zero) + { + void* pMemory = nullptr; + const int retVal = posix_memalign(&pMemory, alignment, size); + if ((retVal == 0) && (pMemory != nullptr) && zero) + { + memset(pMemory, 0, size); + } + + return pMemory; + } + + void FreeMemory(void* pMemory) + { + free(pMemory); + } + + ///////////////////////////////////////////////////// + // Synchronization primatives + // + + void AtomicLock::Lock() + { + // TODO - implement timeout + while (__sync_val_compare_and_swap(&m_lock, 0, 1) == 1) + { + // spin until the mutex is unlocked again + while (m_lock != 0) + { + } + } + } + + void AtomicLock::Unlock() + { + const long result = __sync_val_compare_and_swap(&m_lock, 1, 0); + DD_UNUSED(result); + DD_ASSERT(result != 0); + } + + Mutex::Mutex() + { + const int result = pthread_mutex_init(&m_mutex, nullptr); + DD_UNUSED(result); + DD_ASSERT(result == 0); + } + + Mutex::~Mutex() + { + const int result = pthread_mutex_destroy(&m_mutex); + DD_UNUSED(result); + DD_ASSERT(result == 0); + } + + void Mutex::Lock() + { + const int result = pthread_mutex_lock(&m_mutex); + DD_UNUSED(result); + DD_ASSERT(result == 0); + } + + void Mutex::Unlock() + { + const int result = pthread_mutex_unlock(&m_mutex); + DD_UNUSED(result); + DD_ASSERT(result == 0); + } + +#if defined(DD_LINUX) + Semaphore::Semaphore(uint32 initialCount, uint32 maxCount) + { + // linux doesn't enforce a max. Beware. + DD_UNUSED(maxCount); + + int result = sem_init(&m_semaphore, 0, initialCount); + DD_ASSERT(result == 0); + DD_UNUSED(result); + } + + Semaphore::~Semaphore() + { + int result = sem_destroy(&m_semaphore); + DD_UNUSED(result); + DD_ASSERT(result == 0); + } + + Result Semaphore::Signal() + { + int result = sem_post(&m_semaphore); + DD_ASSERT(result == 0); + return (result == 0) ? Result::Success : Result::Error; + } + + Result Semaphore::Wait(uint32 timeoutInMs) + { + Result result = Result::Error; + + timespec timeout = {}; + + if (GetAbsTime(timeoutInMs, &timeout) == Result::Success) + { + int retVal = RetryTemporaryFailure(sem_timedwait,&m_semaphore, &timeout); + if (retVal != -1) + { + result = Result::Success; + } else if (errno == ETIMEDOUT) + { + result = Result::NotReady; + } + } + return result; + } +#endif + + Event::Event(bool signaled) + { + int result = pthread_mutex_init(&m_event.mutex, nullptr); + DD_UNUSED(result); + DD_ASSERT(result == 0); + + result = pthread_cond_init(&m_event.condition, nullptr); + DD_UNUSED(result); + DD_ASSERT(result == 0); + + m_event.isSet = signaled; + } + + Event::~Event() + { + int result = pthread_cond_destroy(&m_event.condition); + DD_UNUSED(result); + DD_ASSERT(result == 0); + + result = pthread_mutex_destroy(&m_event.mutex); + DD_UNUSED(result); + DD_ASSERT(result == 0); + } + + void Event::Clear() + { + int result = pthread_mutex_lock(&m_event.mutex); + DD_UNUSED(result); + DD_ASSERT(result == 0); + + m_event.isSet = false; + + result = pthread_mutex_unlock(&m_event.mutex); + DD_UNUSED(result); + DD_ASSERT(result == 0); + } + + void Event::Signal() + { + int result = pthread_mutex_lock(&m_event.mutex); + DD_UNUSED(result); + DD_ASSERT(result == 0); + + m_event.isSet = true; + + result = pthread_cond_signal(&m_event.condition); + DD_UNUSED(result); + DD_ASSERT(result == 0); + + result = pthread_mutex_unlock(&m_event.mutex); + DD_UNUSED(result); + DD_ASSERT(result == 0); + } + + Result Event::Wait(uint32 timeoutInMs) + { + Result result = Result::Error; + + timespec timeout = {}; + + if (GetAbsTime(timeoutInMs, &timeout) == Result::Success) + { + int retVal = pthread_mutex_lock(&m_event.mutex); + DD_UNUSED(retVal); + DD_ASSERT(retVal == 0); + + int waitResult = 0; + while (!m_event.isSet && waitResult == 0) + { + waitResult = pthread_cond_timedwait(&m_event.condition, &m_event.mutex, &timeout); + } + + if (waitResult == 0) + { + result = Result::Success; + } else if (waitResult == ETIMEDOUT) + { + result = Result::NotReady; + } + + retVal = pthread_mutex_unlock(&m_event.mutex); + DD_UNUSED(retVal); + DD_ASSERT(retVal == 0); + } + return result; + } + +#if defined(DD_LINUX) + Random::Random() + { + timespec timeValue = {}; + int result = clock_gettime(CLOCK_MONOTONIC, &timeValue); + DD_UNUSED(result); + DD_ASSERT(result == 0); + + // Use the current time to generate a random seed. Has to be 64 bit because seed48_r expects to get + // unsigned short seed[3] as a parameter. + uint64 seed = static_cast(timeValue.tv_sec * 1000000000 + timeValue.tv_nsec); + + // Seed our internal state + seed48_r(reinterpret_cast(&seed), &m_randState); + } + + Random::~Random() + { + } + + uint32 Random::Generate() + { + long int value; + // generate a random number + const int result = mrand48_r(&m_randState, &value); + DD_UNUSED(result); + DD_ASSERT(result >= 0); + // return the result, downcast to a uint32 if necessary + return static_cast(value); + } + +#endif + uint32 Random::Max() + { + return -1; + } + + ProcessId GetProcessId() + { + return static_cast(getpid()); + } + + uint64 GetCurrentTimeInMs() + { + timespec timeValue = {}; + + const int result = clock_gettime(CLOCK_MONOTONIC, &timeValue); + DD_UNUSED(result); + DD_ASSERT(result == 0); + + return static_cast(timeValue.tv_sec * 1000 + timeValue.tv_nsec / 1000000); + } + + void Sleep(uint32 millisecTimeout) + { + timespec relativeTime; + const time_t sec = static_cast(millisecTimeout / 1000); + relativeTime.tv_sec = sec; + relativeTime.tv_nsec = (millisecTimeout - (sec * 1000)) * 1000000; + RetryTemporaryFailure(nanosleep, &relativeTime, &relativeTime); + } + + void GetProcessName(char* buffer, size_t bufferSize) + { + DD_ASSERT(buffer != nullptr); +#if defined(DD_LINUX) + const char* pProcessName = program_invocation_short_name; +#else + const char* pProcessName = getprogname(); +#endif + Strncpy(buffer, (pProcessName != nullptr) ? pProcessName : "Unknown", bufferSize); + + } + + void Strncpy(char* pDst, const char* pSrc, size_t dstSize) + { + DD_ASSERT(pDst != nullptr); + DD_ASSERT(pSrc != nullptr); + DD_ALERT(strlen(pSrc) < dstSize); + + strncpy(pDst, pSrc, (dstSize - 1)); + pDst[dstSize - 1] = '\0'; + } + + void Snprintf(char* pDst, size_t dstSize, const char* format, ...) + { + va_list args; + va_start(args, format); + vsnprintf(pDst, dstSize, format, args); + pDst[dstSize - 1] = '\0'; + va_end(args); + } + + void Vsnprintf(char* pDst, size_t dstSize, const char* format, va_list args) + { + vsnprintf(pDst, dstSize, format, args); + pDst[dstSize - 1] = '\0'; + } + } +} diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/posix/ddPosixSocket.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/posix/ddPosixSocket.cpp new file mode 100644 index 000000000..0f5f29ae3 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/posix/ddPosixSocket.cpp @@ -0,0 +1,621 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file ddPosixSocket.cpp +* @brief POSIX socket implementation +*********************************************************************************************************************** +*/ + +#include "../ddSocket.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include "ddPlatform.h" + +namespace DevDriver +{ + Result GetDataError(bool nonBlocking) + { + Result result = Result::Error; + const int err = errno; + switch (err) + { + case EAGAIN: + if (nonBlocking) + result = Result::NotReady; + break; + case ENOBUFS: + result = Result::NotReady; + break; + case ECONNRESET: + case ENOTCONN: + case ENOENT: + case ENOTDIR: + case ECONNREFUSED: + case EHOSTUNREACH: + case EADDRINUSE: + case EACCES: + case ENETDOWN: + result = Result::Unavailable; + break; + } + return result; + } + + bool IsRWOperationPending() + { + return ((errno == EAGAIN) || (errno == EWOULDBLOCK)); + } + + // ===================================================================================================================== + // Constructs the socket this object encapsulates. + Socket::Socket() + : m_osSocket(-1) + , m_isNonBlocking(false) + , m_socketType(SocketType::Unknown) + , m_hints() + , m_address() + , m_addressSize(0) + { + } + + // ===================================================================================================================== + // Frees the socket this object encapsulates. + Socket::~Socket() + { + if (m_osSocket != -1) + { + Close(); + } + } + + // ===================================================================================================================== + // Initializes socket this object encapsulates. + Result Socket::Init(bool isNonBlocking, SocketType socketType) + { + Result result = Result::Error; + + m_isNonBlocking = isNonBlocking; + m_socketType = socketType; + + if (m_osSocket == -1) + { + switch (socketType) + { + case SocketType::Tcp: + m_osSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + m_hints.ai_family = AF_INET; + m_hints.ai_socktype = SOCK_STREAM; + m_hints.ai_protocol = IPPROTO_TCP; + break; + case SocketType::Udp: + m_osSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); + m_hints.ai_family = AF_INET; + m_hints.ai_socktype = SOCK_DGRAM; + m_hints.ai_protocol = IPPROTO_UDP; + break; + case SocketType::Local: + m_osSocket = socket(AF_UNIX, SOCK_DGRAM, 0); + m_hints.ai_family = AF_UNIX; + m_hints.ai_socktype = SOCK_DGRAM; + m_hints.ai_protocol = 0; + break; + default: + break; + } + + result = (m_osSocket != -1) ? Result::Success : Result::Error; + } + + if ((result == Result::Success) & m_isNonBlocking) + { + // Enable non blocking mode for the socket. + if (fcntl(m_osSocket, F_SETFL, O_NONBLOCK) != 0) + { + result = Result::Error; + } + } + + DD_ASSERT(result != Result::Error); + return result; + } + + Result Socket::Connect(const char* pAddress, uint32 port) + { + char sockAddress[kMaxStringLength] = {}; + size_t addressSize = 0; + Result result = LookupAddressInfo(pAddress, port, sizeof(sockAddress), &sockAddress[0], &addressSize); + if (result == Result::Success) + { + const int retVal = Platform::RetryTemporaryFailure(connect, + m_osSocket, + reinterpret_cast(&sockAddress[0]), + addressSize); + + if (retVal == 0) + { + result = Result::Success; + } + else if (retVal == -1) + { + result = GetDataError(m_isNonBlocking); + } + else + { + result = Result::Error; + } + } + DD_ASSERT(result != Result::Error); + return result; + } + + Result Socket::Select(bool* pReadState, bool* pWriteState, bool* pExceptState, uint32 timeoutInMs) + { + Result result = Result::Error; + + fd_set readSet = {}; + fd_set writeSet = {}; + fd_set exceptSet = {}; + + FD_SET(m_osSocket, &readSet); + FD_SET(m_osSocket, &writeSet); + FD_SET(m_osSocket, &exceptSet); + + timeval timeoutValue = {}; + timeoutValue.tv_sec = static_cast(timeoutInMs) / 1000; + timeoutValue.tv_usec = (static_cast(timeoutInMs) % 1000) * 1000; + + fd_set* pReadSet = ((pReadState != nullptr) ? &readSet : nullptr); + fd_set* pWriteSet = ((pWriteState != nullptr) ? &writeSet : nullptr); + fd_set* pExceptSet = ((pExceptState != nullptr) ? &exceptSet : nullptr); + + const int retval = Platform::RetryTemporaryFailure(select, + m_osSocket + 1, + pReadSet, + pWriteSet, + pExceptSet, + &timeoutValue); + + if (retval > 0) + { + result = Result::Success; + } + else + { + result = (retval == 0) ? Result::NotReady : Result::Error; + } + + if (pReadState != nullptr) + { + *pReadState = (FD_ISSET(m_osSocket, pReadSet) != 0); + } + + if (pWriteState != nullptr) + { + *pWriteState = (FD_ISSET(m_osSocket, pWriteSet) != 0); + } + + if (pExceptState != nullptr) + { + *pExceptState = (FD_ISSET(m_osSocket, pExceptSet) != 0); + } + + DD_ASSERT(result != Result::Error); + return result; + } + + Result Socket::Bind(const char* pAddress, uint32 port) + { + Result result = Result::Error; + + if (m_socketType == SocketType::Local) + { + DD_ASSERT(sizeof(m_address) >= sizeof(sockaddr_un)); + + m_addressSize = 0; + + sockaddr_un* DD_RESTRICT pAddr = reinterpret_cast(&m_address[0]); + pAddr->sun_family = AF_UNIX; + pAddr->sun_path[0] = '\0'; + +#if defined(DD_LINUX) + if (pAddress != nullptr) + { + // Start the path with a null byte to bind as an abstract socket. + Platform::Strncpy(pAddr->sun_path + 1, pAddress, sizeof(pAddr->sun_path) - 2); + m_addressSize = sizeof(sockaddr_un); + } + else + { + m_addressSize = sizeof(sa_family_t); + } +#else + if (pAddress != nullptr) + { + Platform::Strncpy(pAddr->sun_path, pAddress, sizeof(pAddr->sun_path) - 1); + } + else + { + // If pAddress is null we attempt to generate a random filesystem path to bind to + DD_STATIC_CONST char kUnixSocketTemplate[] = "/tmp/com.amd.gpuopen-XXXXXX"; + Platform::Strncpy(pAddr->sun_path, kUnixSocketTemplate, sizeof(pAddr->sun_path) - 1); + const char* pPath = mktemp(pAddr->sun_path); + DD_ASSERT(pPath != nullptr); + } + m_addressSize = SUN_LEN(pAddr); +#endif + + // As a precaution, we unlink the address before we attempt to bind to it + // We have to do this because we have no way of determining whether or not the file has been orphaned + // by another process or not. It is *extremely* important to ensure that the bind address passed into + // the socket is not a file as this can cause data loss. + if (pAddr->sun_path[0] != 0) + { + unlink(&pAddr->sun_path[0]); + } + + // We bind the socket to the address that was either provided or generated. + if (bind(m_osSocket, reinterpret_cast(pAddr), m_addressSize) != -1) + { + result = Result::Success; + } + else + { + const int err = errno; + DD_UNUSED(err); + DD_ASSERT_REASON("Bind failed"); + } + } + else + { + addrinfo hints = m_hints; + hints.ai_flags = AI_PASSIVE; + + char portBuffer[16]; + snprintf(portBuffer, sizeof(portBuffer), "%d", port); + + addrinfo* pResult = nullptr; + int retVal = getaddrinfo(pAddress, portBuffer, &hints, &pResult); + + if (retVal == 0) + { + sockaddr* addr = pResult->ai_addr; + size_t addrSize = pResult->ai_addrlen; + + if (bind(m_osSocket, addr, static_cast(addrSize)) != -1) + { + result = Result::Success; + } + + freeaddrinfo(pResult); + } + } + + DD_ASSERT(result != Result::Error); + return result; + } + + Result Socket::Listen(uint32 backlog) + { + DD_ASSERT(m_socketType == SocketType::Tcp); + + Result result = Result::Error; + + if (listen(m_osSocket, backlog) != -1) + { + result = Result::Success; + } + + return result; + } + + Result Socket::Accept(Socket* pClientSocket) + { + DD_ASSERT(m_socketType == SocketType::Tcp); + + Result result = Result::Error; + + sockaddr addr = {}; + socklen_t addrSize = sizeof(addr); + + const int clientSocket = Platform::RetryTemporaryFailure(accept, + m_osSocket, + &addr, + &addrSize); + if (clientSocket != -1) + { + sockaddr_in* pSocket = reinterpret_cast(&addr); + + const unsigned int addressBufSize = 256; + char addressBuf[addressBufSize]; + const char* pAddress = inet_ntop(AF_INET, reinterpret_cast(&pSocket->sin_addr), addressBuf, addressBufSize); + + unsigned int port = ntohs(pSocket->sin_port); + + result = pClientSocket->InitAsClient(clientSocket, pAddress, port, m_isNonBlocking); + } + + return result; + } + + Result Socket::LookupAddressInfo(const char* pAddress, uint32 port, size_t addressInfoSize, char* pAddressInfo, size_t *pAddressSize) + { + Result result = Result::Error; + switch (m_socketType) + { + case SocketType::Tcp: + case SocketType::Udp: + { + DD_ASSERT(addressInfoSize >= sizeof(sockaddr)); + + char portBuffer[16]; + snprintf(portBuffer, sizeof(portBuffer), "%d", port); + + addrinfo* pResult = nullptr; + int retVal = getaddrinfo(pAddress, portBuffer, &m_hints, &pResult); + + if (retVal == 0) + { + sockaddr* addr = pResult->ai_addr; + const size_t& addrSize = pResult->ai_addrlen; + if (addressInfoSize >= addrSize) + { + memcpy(pAddressInfo, addr, addrSize); + *pAddressSize = addrSize; + result = Result::Success; + } + + freeaddrinfo(pResult); + } + break; + } + case SocketType::Local: + { + DD_ASSERT(addressInfoSize >= sizeof(sockaddr_un)); + + sockaddr_un* DD_RESTRICT pAddr = reinterpret_cast(pAddressInfo); + pAddr->sun_family = AF_UNIX; + + // Start the path with a null byte to bind as an abstract socket. + pAddr->sun_path[0] = '\0'; + Platform::Strncpy(pAddr->sun_path + 1, pAddress, sizeof(pAddr->sun_path) - 2); + *pAddressSize = sizeof(sockaddr_un); + result = Result::Success; + break; + } + default: + DD_UNREACHABLE(); + break; + } + DD_ASSERT(result != Result::Error); + return result; + } + + Result Socket::Send(const uint8* pData, size_t dataSize, size_t* pBytesSent) + { + Result result = Result::Error; + + const int retVal = Platform::RetryTemporaryFailure(send, + m_osSocket, + reinterpret_cast(pData), + static_cast(dataSize), + 0); + if (retVal != -1) + { + *pBytesSent = retVal; + result = Result::Success; + } + else + { + *pBytesSent = 0; + if (retVal == 0) + { + result = Result::Unavailable; + } + else + { + result = GetDataError(m_isNonBlocking); + } + } + + return result; + } + + Result Socket::SendTo(const void *pSockAddr, size_t addrSize, const uint8 *pData, size_t dataSize) + { + DD_ASSERT((m_socketType == SocketType::Udp) || (m_socketType == SocketType::Local)); + + Result result = Result::Error; + + const int retVal = Platform::RetryTemporaryFailure(sendto, + m_osSocket, + reinterpret_cast(pData), + static_cast(dataSize), + 0, + reinterpret_cast(pSockAddr), + addrSize); + + if (static_cast(retVal) == dataSize) + { + result = Result::Success; + } + else if (retVal == 0) + { + result = Result::Unavailable; + } + else + { + result = GetDataError(m_isNonBlocking); + } + + return result; + } + + Result Socket::Receive(uint8* pBuffer, size_t bufferSize, size_t* pBytesReceived) + { + Result result = Result::Error; + + const int retVal = Platform::RetryTemporaryFailure(recv, + m_osSocket, + reinterpret_cast(pBuffer), + static_cast(bufferSize), + 0); + if (retVal > 0) + { + *pBytesReceived = retVal; + result = Result::Success; + } + else + { + if (retVal == 0) + { + result = Result::Unavailable; + } + else + { + result = GetDataError(m_isNonBlocking); + } + } + + return result; + } + + Result Socket::ReceiveFrom(void *pSockAddr, size_t *addrSize, uint8 *pBuffer, size_t bufferSize) + { + DD_ASSERT((m_socketType == SocketType::Udp) || (m_socketType == SocketType::Local)); + DD_ASSERT(*addrSize >= sizeof(sockaddr)); + + Result result = Result::Error; + + const int retVal = Platform::RetryTemporaryFailure(recvfrom, + m_osSocket, + reinterpret_cast(pBuffer), + static_cast(bufferSize), + 0, + reinterpret_cast(pSockAddr), + reinterpret_cast(addrSize)); + + if (retVal > 0) + { + result = Result::Success; + } + else if (retVal == 0) + { + result = Result::Unavailable; + } + else + { + result = GetDataError(m_isNonBlocking); + } + + return result; + } + + Result Socket::Close() + { + Result result = Result::Error; + + // Shut down the socket before closing it. + // The result doesn't matter since we're closing it anyways. + shutdown(m_osSocket, SHUT_RDWR); + + if (close(m_osSocket) != -1) + { + m_osSocket = -1; + if (m_socketType == SocketType::Local) + { + sockaddr_un* DD_RESTRICT pAddr = reinterpret_cast(&m_address[0]); + // If the socket wasn't in the abstract namespace, unlink it from the filesystem + if (pAddr->sun_path[0] != 0) + { + unlink(&pAddr->sun_path[0]); + } + } + result = Result::Success; + } + + return result; + } + + Result Socket::GetSocketName(char *pAddress, size_t addrLen, uint32 *pPort) + { + Result result = Result::Error; + socklen_t len = static_cast(sizeof(sockaddr)); + sockaddr addr; + if (getsockname(m_osSocket, &addr, &len) == 0) + { + sockaddr_in* pAddr = reinterpret_cast(&addr); + const char* pResult = inet_ntop(AF_INET, reinterpret_cast(&pAddr->sin_addr), pAddress, addrLen); + + if (pResult != NULL) + { + unsigned int port = ntohs(pAddr->sin_port); + *pPort = port; + result = Result::Success; + } + } + return result; + } + + Result Socket::InitAsClient(OsSocketType socket, const char* pAddress, uint32 port, bool isNonBlocking) + { + + DD_ASSERT(m_socketType == SocketType::Tcp); + DD_UNUSED(pAddress); + DD_UNUSED(port); + + Result result = Result::Success; + + m_isNonBlocking = isNonBlocking; + + m_osSocket = socket; + + result = (m_osSocket != -1) ? Result::Success : Result::Error; + + if (result == Result::Success) + { + if (m_isNonBlocking) + { + // Enable non blocking mode for the socket. + result = (fcntl(m_osSocket, F_SETFL, O_NONBLOCK) == 0) ? Result::Success : Result::Error; + } + } + + return result; + } + +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/ddGpuCrashDumpClient.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/ddGpuCrashDumpClient.cpp new file mode 100644 index 000000000..31bd8e62f --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/ddGpuCrashDumpClient.cpp @@ -0,0 +1,187 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "protocols/ddGpuCrashDumpClient.h" +#include "ddTransferManager.h" +#include "msgChannel.h" + +#define GPUCRASHDUMP_CLIENT_MIN_MAJOR_VERSION 1 +#define GPUCRASHDUMP_CLIENT_MAX_MAJOR_VERSION 1 + +namespace DevDriver +{ + namespace GpuCrashDumpProtocol + { + GpuCrashDumpClient::GpuCrashDumpClient(IMsgChannel* pMsgChannel) + : BaseProtocolClient(pMsgChannel, Protocol::GpuCrashDump, GPUCRASHDUMP_CLIENT_MIN_MAJOR_VERSION, GPUCRASHDUMP_CLIENT_MAX_MAJOR_VERSION) + , m_pCrashDump(nullptr) + , m_crashDumpSize(0) + , m_crashDumpBytesSent(0) + { + } + + GpuCrashDumpClient::~GpuCrashDumpClient() + { + } + + Result GpuCrashDumpClient::BeginGpuCrashDump(const void* pCrashDump, size_t crashDumpSize) + { + Result result = Result::Error; + + // Make sure we're connected and aren't already in the middle of reporting a crash. + if (IsConnected() && (m_pCrashDump == nullptr)) + { + // Attempt to acquire memory for the crash data. + m_pCrashDump = reinterpret_cast(DD_MALLOC(crashDumpSize, + DD_DEFAULT_ALIGNMENT, + m_pMsgChannel->GetAllocCb())); + if (m_pCrashDump != nullptr) + { + // Copy the crash data into the memory. + memcpy(m_pCrashDump, pCrashDump, crashDumpSize); + + // Send a notification payload to the server. + GpuCrashDumpPayload payload = {}; + payload.command = GpuCrashDumpMessage::GpuCrashNotify; + payload.notify.sizeInBytes = static_cast(crashDumpSize); // @todo: Support 4GB+ crashes? + + // Exchange messages. Make sure we get the correct command back. + result = Transact(payload, payload); + if ((result == Result::Success) && (payload.command == GpuCrashDumpMessage::GpuCrashAcknowledge)) + { + // Check if the server wants the crash dump. + if (payload.acknowledge.acceptedCrashDump) + { + // The notification was successfully acknowledged. Save the crash data size and reset the + // bytes sent. + m_crashDumpSize = static_cast(crashDumpSize); + m_crashDumpBytesSent = 0; + + result = Result::Success; + } + else + { + // The server rejected the crash notification. Release the crash data memory. + DD_FREE(m_pCrashDump, m_pMsgChannel->GetAllocCb()); + m_pCrashDump = nullptr; + + result = Result::Rejected; + } + } + else + { + // The server did not acknowledge the crash notification. Release the crash data memory. + DD_FREE(m_pCrashDump, m_pMsgChannel->GetAllocCb()); + m_pCrashDump = nullptr; + + result = Result::Error; + } + } + else + { + // Failed to acquire memory for crash data. + result = Result::Error; + } + } + + return result; + } + + Result GpuCrashDumpClient::EndGpuCrashDump() + { + Result result = Result::Error; + + // We should always have valid crash data memory if we're in the middle of the gpu crash process. + if (m_pCrashDump != nullptr) + { + // We should never have valid crash data memory when we've finished transferring all the crash data. + DD_ASSERT(m_crashDumpBytesSent < m_crashDumpSize); + + GpuCrashDumpPayload payload = {}; + payload.command = GpuCrashDumpMessage::GpuCrashDataChunk; + + // Send a new crash data chunk. + // Calculate the number of bytes to send. + // We need to send a partial chunk if the number of bytes sent + the data chunk size would + // be larger than the number of total bytes. + const uint32 bytesToSend = + ((m_crashDumpBytesSent + kMaxGpuCrashDumpDataChunkSize > m_crashDumpSize) ? + (m_crashDumpSize - m_crashDumpBytesSent) : + kMaxGpuCrashDumpDataChunkSize); + + memcpy(payload.dataChunk.data, m_pCrashDump + m_crashDumpBytesSent, bytesToSend); + + result = SendPayload(payload); + + if (result == Result::Success) + { + // We successfully sent a chunk. Update the number of bytes sent. + m_crashDumpBytesSent += bytesToSend; + + // Make sure we haven't somehow sent too much data. + DD_ASSERT(m_crashDumpBytesSent <= m_crashDumpSize); + + // If we've sent all the data, send the sentinel. + if (m_crashDumpBytesSent == m_crashDumpSize) + { + payload.command = GpuCrashDumpMessage::GpuCrashDataSentinel; + payload.sentinel.result = Result::Success; + + result = SendPayload(payload); + + // If we successfully sent the sentinel, return end of stream. + if (result == Result::Success) + { + result = Result::EndOfStream; + } + else + { + // If we fail to send the sentinel, return an error. + result = Result::Error; + } + } + else + { + // We still have more chunks to send but we sent a chunk successfully. Return the existing success result. + } + } + else + { + // We failed to send a chunk, return an error. + result = Result::Error; + } + + // Release the crash data memory before returning if there are no more chunks. + if (result != Result::Success) + { + DD_FREE(m_pCrashDump, m_pMsgChannel->GetAllocCb()); + m_pCrashDump = nullptr; + } + } + + return result; + } +} + +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/ddGpuCrashDumpServer.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/ddGpuCrashDumpServer.cpp new file mode 100644 index 000000000..4e2668d76 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/ddGpuCrashDumpServer.cpp @@ -0,0 +1,316 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "protocols/ddGpuCrashDumpServer.h" +#include "msgChannel.h" +#include "ddTransferManager.h" + +#define GPUCRASHDUMP_SERVER_MIN_MAJOR_VERSION 1 +#define GPUCRASHDUMP_SERVER_MAX_MAJOR_VERSION 1 + +namespace DevDriver +{ + namespace GpuCrashDumpProtocol + { + // Session state enumeration + enum class SessionState + { + WaitForCrashDump = 0, + SendAcknowledgement, + TransferCrashDump + }; + + // Session object + struct GpuCrashDumpSession + { + SessionState state; + GpuCrashDumpPayload payload; + uint32 crashDataTotalSizeInBytes; + uint32 crashDataBytesReceived; + void* pUserdata; + }; + + GpuCrashDumpServer::GpuCrashDumpServer(IMsgChannel* pMsgChannel) + : BaseProtocolServer(pMsgChannel, Protocol::GpuCrashDump, GPUCRASHDUMP_SERVER_MIN_MAJOR_VERSION, GPUCRASHDUMP_SERVER_MAX_MAJOR_VERSION) + , m_pCrashDumpHandler(nullptr) + , m_numSessions(0) + { + } + + GpuCrashDumpServer::~GpuCrashDumpServer() + { + } + + bool GpuCrashDumpServer::AcceptSession(const SharedPointer& pSession) + { + DD_UNUSED(pSession); + + bool accept = false; + + m_mutex.Lock(); + + // Only accept sessions if we have a crash handler installed. + if (m_pCrashDumpHandler != nullptr) + { + // Keep track of the number of sessions. + m_numSessions++; + + accept = true; + } + + m_mutex.Unlock(); + + return accept; + } + + void GpuCrashDumpServer::SessionEstablished(const SharedPointer& pSession) + { + // Allocate session data for the newly established session + GpuCrashDumpSession* pSessionData = DD_NEW(GpuCrashDumpSession, m_pMsgChannel->GetAllocCb())(); + pSessionData->state = SessionState::WaitForCrashDump; + pSessionData->payload = {}; + pSessionData->pUserdata = nullptr; + + pSession->SetUserData(pSessionData); + } + + void GpuCrashDumpServer::UpdateSession(const SharedPointer& pSession) + { + GpuCrashDumpSession* pSessionData = reinterpret_cast(pSession->GetUserData()); + + // We should always have a valid crash handler when any sessions are active. + DD_ASSERT(m_pCrashDumpHandler != nullptr); + + switch (pSessionData->state) + { + case SessionState::WaitForCrashDump: + { + uint32 bytesReceived = 0; + const Result result = pSession->Receive(sizeof(pSessionData->payload), &pSessionData->payload, &bytesReceived, kNoWait); + if (result == Result::Success) + { + DD_ASSERT(sizeof(pSessionData->payload) == bytesReceived); + + if (pSessionData->payload.command == GpuCrashDumpMessage::GpuCrashNotify) + { + // Extract the relevant info from the notification. + const uint32 sizeInBytes = pSessionData->payload.notify.sizeInBytes; + const ClientId clientId = pSession->GetDestinationClientId(); + + // Send an acknowledgement back. + pSessionData->state = SessionState::SendAcknowledgement; + pSessionData->payload.command = GpuCrashDumpMessage::GpuCrashAcknowledge; + + // Call the crash available callback and check if we want this crash dump. + const bool acceptCrash = m_pCrashDumpHandler->AcceptCrashDump(static_cast(sizeInBytes), clientId, &pSessionData->pUserdata); + + // Set payload value for ack based on callback. + pSessionData->payload.acknowledge.acceptedCrashDump = acceptCrash; + + // Save the size of the crash data and reset the bytes received. + pSessionData->crashDataTotalSizeInBytes = sizeInBytes; + pSessionData->crashDataBytesReceived = 0; + } + else + { + // We should only ever receive crash notifications in this state. + DD_ALERT_REASON("Invalid message received while waiting on crash dump acknowledgement"); + + // Ignore the message. + } + } + else if (result != Result::NotReady) + { + // We've encountered an error while attempting to read from the session. + // Do nothing since the session will close itself automatically. + } + + break; + } + + case SessionState::SendAcknowledgement: + { + // Make sure we have the correct command. + DD_ASSERT(pSessionData->payload.command == GpuCrashDumpMessage::GpuCrashAcknowledge); + + // Attempt to send the acknowledgement. + const Result result = pSession->Send(sizeof(pSessionData->payload), &pSessionData->payload, kNoWait); + if (result == Result::Success) + { + // Transition to the transfer state to begin transferring the crash dump if we accepted the crash. + if (pSessionData->payload.acknowledge.acceptedCrashDump) + { + pSessionData->state = SessionState::TransferCrashDump; + } + else + { + // We successfully rejected the crash, transition back to the waiting state. + pSessionData->state = SessionState::WaitForCrashDump; + } + } + else if (result != Result::NotReady) + { + // We've encountered an error while trying to acknowledge the crash. + + // Let the crash handler know that the transfer is ending if we previously accepted the crash. + if (pSessionData->payload.acknowledge.acceptedCrashDump) + { + m_pCrashDumpHandler->FinishCrashDumpTransfer(false, pSessionData->pUserdata); + } + + // Transition back to the waiting state. + pSessionData->state = SessionState::WaitForCrashDump; + } + + break; + } + + case SessionState::TransferCrashDump: + { + uint32 bytesReceived = 0; + const Result result = pSession->Receive(sizeof(pSessionData->payload), &pSessionData->payload, &bytesReceived, kNoWait); + if (result == Result::Success) + { + DD_ASSERT(sizeof(pSessionData->payload) == bytesReceived); + + if (pSessionData->payload.command == GpuCrashDumpMessage::GpuCrashDataChunk) + { + // Only receive the chunk if we're still looking for data. + if (pSessionData->crashDataBytesReceived < pSessionData->crashDataTotalSizeInBytes) + { + // Determine the number of bytes in the chunk. + // If the current size + the max chunk size is greater than the total, that means this chunk is only partially full + // since we can't have more bytes than the total. + const uint32 numBytesInChunk = + ((pSessionData->crashDataBytesReceived + kMaxGpuCrashDumpDataChunkSize > pSessionData->crashDataTotalSizeInBytes) ? + (pSessionData->crashDataTotalSizeInBytes - pSessionData->crashDataBytesReceived) : + kMaxGpuCrashDumpDataChunkSize); + + // We successfully read crash dump data from the remote client. Call the client's handler. + m_pCrashDumpHandler->ReceiveCrashDumpData(pSessionData->payload.dataChunk.data, + numBytesInChunk, + pSessionData->pUserdata); + + // Update the number of bytes received. + pSessionData->crashDataBytesReceived += numBytesInChunk; + } + else + { + // End the transfer and transition back to the waiting state. + m_pCrashDumpHandler->FinishCrashDumpTransfer(false, pSessionData->pUserdata); + pSessionData->state = SessionState::WaitForCrashDump; + + // This should never happen. If we hit this, the remote client is sending more chunks than necessary. + DD_ALERT_REASON("Server received more chunks than expected"); + } + } + else if (pSessionData->payload.command == GpuCrashDumpMessage::GpuCrashDataSentinel) + { + // Let the crash handler know that we're finished with the transfer. + m_pCrashDumpHandler->FinishCrashDumpTransfer((pSessionData->payload.sentinel.result == Result::Success), + pSessionData->pUserdata); + + // Transition back to the waiting state. + pSessionData->state = SessionState::WaitForCrashDump; + } + else + { + // End the transfer and transition back to the waiting state. + m_pCrashDumpHandler->FinishCrashDumpTransfer(false, pSessionData->pUserdata); + pSessionData->state = SessionState::WaitForCrashDump; + + // Invalid command? + DD_ALERT_REASON("Invalid command received"); + } + } + else if (result != Result::NotReady) + { + // We've encountered some sort of error during the transfer. Let the crash handler know and end the transfer. + m_pCrashDumpHandler->FinishCrashDumpTransfer(false, pSessionData->pUserdata); + + // Transition back to the waiting state. + pSessionData->state = SessionState::WaitForCrashDump; + } + + break; + } + + default: + { + DD_UNREACHABLE(); + break; + } + } + } + + void GpuCrashDumpServer::SessionTerminated(const SharedPointer& pSession, Result terminationReason) + { + DD_UNUSED(terminationReason); + + m_mutex.Lock(); + + // Update the session counter. + m_numSessions--; + + m_mutex.Unlock(); + + GpuCrashDumpSession* pGpuCrashDumpSession = reinterpret_cast(pSession->SetUserData(nullptr)); + + // Free the session data + if (pGpuCrashDumpSession != nullptr) + { + DD_DELETE(pGpuCrashDumpSession, m_pMsgChannel->GetAllocCb()); + } + } + + Result GpuCrashDumpServer::SetCrashDumpHandler(ICrashDumpHandler* pHandler) + { + Result result = Result::Error; + + m_mutex.Lock(); + + // Only allow the caller to change the handler if there are no active sessions. + if (m_numSessions == 0) + { + m_pCrashDumpHandler = pHandler; + result = Result::Success; + } + + m_mutex.Unlock(); + + return result; + } + + ICrashDumpHandler* GpuCrashDumpServer::GetCrashDumpHandler() + { + m_mutex.Lock(); + + ICrashDumpHandler* pHandler = m_pCrashDumpHandler; + + m_mutex.Unlock(); + + return pHandler; + } + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/ddTransferClient.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/ddTransferClient.cpp new file mode 100644 index 000000000..2a871e3b5 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/ddTransferClient.cpp @@ -0,0 +1,438 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "protocols/ddTransferClient.h" +#include + +#define TRANSFER_CLIENT_MIN_MAJOR_VERSION 1 +#define TRANSFER_CLIENT_MAX_MAJOR_VERSION 2 + +namespace DevDriver +{ + namespace TransferProtocol + { + // ============================================================================================================ + TransferClient::TransferClient(IMsgChannel* pMsgChannel) + : BaseProtocolClient(pMsgChannel, + Protocol::Transfer, + TRANSFER_CLIENT_MIN_MAJOR_VERSION, + TRANSFER_CLIENT_MAX_MAJOR_VERSION) + { + memset(&m_transferContext, 0, sizeof(m_transferContext)); + } + + // ============================================================================================================ + TransferClient::~TransferClient() + { + } + + // ============================================================================================================ + Result TransferClient::RequestPullTransfer(BlockId blockId, size_t* pTransferSizeInBytes) + { + Result result = Result::Error; + + if ((m_transferContext.state == TransferState::Idle) && + (pTransferSizeInBytes != nullptr)) + { + SizedPayloadContainer container = {}; + container.CreatePayload(blockId, TransferType::Pull, 0); + + result = TransactTransferPayload(&container); + + if ((result == Result::Success) && + (container.GetPayload().command == TransferMessage::TransferDataHeader)) + { + // We've successfully received the transfer data header. Check if the transfer request was successful. + if (m_pSession->GetVersion() >= TRANSFER_REFACTOR_VERSION) + { + const TransferDataHeaderV2& receivedHeader = container.GetPayload(); + m_transferContext.state = TransferState::TransferInProgress; + m_transferContext.totalBytes = receivedHeader.sizeInBytes; + m_transferContext.crc32 = 0; + m_transferContext.dataChunkSizeInBytes = 0; + m_transferContext.dataChunkBytesTransfered = 0; + + *pTransferSizeInBytes = receivedHeader.sizeInBytes; + } + else + { + const TransferDataHeader& receivedHeader = container.GetPayload(); + result = receivedHeader.result; + if (result == Result::Success) + { + m_transferContext.state = TransferState::TransferInProgress; + m_transferContext.totalBytes = receivedHeader.sizeInBytes; + m_transferContext.crc32 = 0; + m_transferContext.dataChunkSizeInBytes = 0; + m_transferContext.dataChunkBytesTransfered = 0; + m_transferContext.type = TransferType::Pull; + + *pTransferSizeInBytes = receivedHeader.sizeInBytes; + } + else + { + // The transfer failed on the remote server. + m_transferContext.state = TransferState::Error; + result = Result::Error; + } + } + } + else + { + // We either didn't receive a response, or we received an invalid response. + m_transferContext.state = TransferState::Error; + result = Result::Error; + } + } + + return result; + } + + // ============================================================================================================ + Result TransferClient::ReadPullTransferData(uint8* pDstBuffer, size_t bufferSize, size_t* pBytesRead) + { + Result result = Result::Error; + + if ((m_transferContext.state == TransferState::TransferInProgress) && (pBytesRead != nullptr)) + { + result = Result::Success; + + // There is no remaining data to read + if ((m_transferContext.totalBytes == 0) && + (m_transferContext.dataChunkSizeInBytes == m_transferContext.dataChunkBytesTransfered)) + { + result = Result::EndOfStream; + m_transferContext.state = TransferState::Idle; + *pBytesRead = 0; + } + else if (bufferSize > 0) + { + SizedPayloadContainer& scratchPayload = m_transferContext.scratchPayload; + + // There's space available in the caller's buffer, attempt to write data into it. + size_t remainingBufferSize = bufferSize; + while ((remainingBufferSize > 0) && + (m_transferContext.state == TransferState::TransferInProgress)) + { + // If we have local data, read from that. + const size_t dataChunkBytesAvailable = + (m_transferContext.dataChunkSizeInBytes - m_transferContext.dataChunkBytesTransfered); + + if (dataChunkBytesAvailable > 0) + { + DD_ASSERT(scratchPayload.GetPayload().command == TransferMessage::TransferDataChunk); + const TransferDataChunk& chunk = + scratchPayload.GetPayload(); + + const size_t bytesToRead = Platform::Min(remainingBufferSize, dataChunkBytesAvailable); + const uint8* pData = (chunk.data + m_transferContext.dataChunkBytesTransfered); + memcpy(pDstBuffer + (bufferSize - remainingBufferSize), pData, bytesToRead); + m_transferContext.dataChunkBytesTransfered += bytesToRead; + remainingBufferSize -= bytesToRead; + + // If this is the last of the data for the transfer, return end of stream and return to the idle state. + if ((m_transferContext.dataChunkBytesTransfered == m_transferContext.dataChunkSizeInBytes) && + (m_transferContext.totalBytes == 0)) + { + result = Result::EndOfStream; + m_transferContext.state = TransferState::Idle; + } + } + else if (m_transferContext.totalBytes > 0) + { + // Attempt to fetch a new chunk if we're out of data. + result = ReceiveTransferPayload(&m_transferContext.scratchPayload, kTransferChunkTimeoutInMs); + + const TransferDataChunk& chunk = + scratchPayload.GetPayload(); + + if ((result == Result::Success) && + (chunk.command == TransferMessage::TransferDataChunk)) + { + // Calculate the remaining payload size. We clamp this to the minimum of the payload + // size specified and how many bytes are remaining. This works on the V1 protocol + // as all packets are guaranteed to be a full payload size, except for the last + // packet. That packet should be equal to the number of total bytes remaining. + // On V2 sessions, a server is free to send arbitrary sized chunks in situations + // that require it + const size_t receivedSize = scratchPayload.payloadSize - sizeof(TransferHeader); + const size_t payloadSize = Platform::Min(receivedSize, kMaxTransferDataChunkSize); + const uint32 adjustedPayloadSize = Platform::Min(static_cast(payloadSize), + m_transferContext.totalBytes); + + // Adjust global state + m_transferContext.dataChunkSizeInBytes = adjustedPayloadSize; + m_transferContext.dataChunkBytesTransfered = 0; + m_transferContext.totalBytes -= adjustedPayloadSize; + + // Update the calculated CRC using the chunk we just received. The existing CRC value + // is used as an input, ensuring that we calculate the same value as the server. + m_transferContext.crc32 = CRC32(&chunk.data[0], + adjustedPayloadSize, + m_transferContext.crc32); + + // If that was the last chunk we consume and verify the sentinel + if (m_transferContext.totalBytes == 0) + { + SizedPayloadContainer sentinelPayload = {}; + result = ReceiveTransferPayload(&sentinelPayload, kTransferChunkTimeoutInMs); + + TransferDataSentinel& sentinel = sentinelPayload.GetPayload(); + + // If we didn't receive a sentinel or the read failed we return an error, otherwise + if ((result != Result::Success) || + (sentinel.command != TransferMessage::TransferDataSentinel) || + (sentinel.result != Result::Success)) + { + // Failed to receive the sentinel. Fail the transfer. + m_transferContext.state = TransferState::Error; + } + else + { + // Check CRC + if ((m_pSession->GetVersion() >= TRANSFER_REFACTOR_VERSION) && + (sentinel.crc32 != m_transferContext.crc32)) + { + m_transferContext.state = TransferState::Error; + } + } + } + } + else + { + // Failed to receive a transfer data chunk. Fail the transfer. + DD_ALERT_REASON("Pull transfer session received invalid data"); + m_transferContext.state = TransferState::Error; + } + } + } + + *pBytesRead = (bufferSize - remainingBufferSize); + } + else + { + // No space available for writing in the caller's buffer. + *pBytesRead = 0; + } + } + + return result; + } + + // ============================================================================================================ + Result TransferClient::RequestPushTransfer(BlockId blockId, size_t transferSizeInBytes) + { + Result result = Result::Error; + if ((m_transferContext.state == TransferState::Idle) && + (m_pSession->GetVersion() >= TRANSFER_REFACTOR_VERSION) && + (blockId != kInvalidBlockId) && + (transferSizeInBytes != 0)) + { + SizedPayloadContainer container = {}; + container.CreatePayload(blockId, + TransferType::Push, + static_cast(transferSizeInBytes)); + Result transactResult = TransactTransferPayload(&container); + if ((transactResult == Result::Success) && + (container.GetPayload().command == TransferMessage::TransferStatus) && + (container.GetPayload().result == Result::Success)) + { + m_transferContext.type = TransferType::Push; + m_transferContext.state = TransferState::TransferInProgress; + m_transferContext.totalBytes = static_cast(transferSizeInBytes); + m_transferContext.crc32 = 0; + m_transferContext.dataChunkSizeInBytes = 0; + m_transferContext.dataChunkBytesTransfered = 0; + result = Result::Success; + } + } + return result; + } + + // ============================================================================================================ + Result TransferClient::WritePushTransferData(const uint8* pSrcBuffer, size_t bufferSize) + { + Result result = Result::Error; + if ((m_transferContext.state == TransferState::TransferInProgress) && + (m_transferContext.type == TransferType::Push)) + { + while ((m_transferContext.totalBytes > 0) & (bufferSize > 0)) + { + const size_t maxBytesInChunk = Platform::Min(kMaxTransferDataChunkSize, + static_cast(m_transferContext.totalBytes)); + const size_t bytesToSend = Platform::Min(maxBytesInChunk, bufferSize); + + m_transferContext.crc32 = CRC32(pSrcBuffer, + bytesToSend, + m_transferContext.crc32); + + TransferDataChunk::WritePayload(pSrcBuffer, bytesToSend, &m_transferContext.scratchPayload); + result = SendTransferPayload(m_transferContext.scratchPayload); + if (result == Result::Success) + { + bufferSize -= bytesToSend; + pSrcBuffer += bytesToSend; + } + else if (result != Result::NotReady) + { + break; + } + } + + if ((m_transferContext.totalBytes == 0) & (bufferSize > 0)) + { + result = Result::EndOfStream; + } + } + + return result; + } + + // ============================================================================================================ + Result TransferClient::ClosePushTransfer(bool discard) + { + Result result = Result::Error; + if ((m_transferContext.state == TransferState::TransferInProgress) && + (m_transferContext.type == TransferType::Push)) + { + SizedPayloadContainer container = {}; + container.CreatePayload(discard ? Result::Aborted : Result::Success, + m_transferContext.crc32); + + if ((TransactTransferPayload(&container) == Result::Success) && + (container.GetPayload().command == TransferMessage::TransferStatus)) + { + result = container.GetPayload().result; + m_transferContext.state = TransferState::Idle; + } + } + + if ((result != Result::Success) && (result != Result::Aborted)) + { + m_transferContext.state = TransferState::Error; + } + + return result; + } + + // ============================================================================================================ + Result TransferClient::AbortPullTransfer() + { + Result result = Result::Error; + + if ((m_transferContext.state == TransferState::TransferInProgress) && + (m_transferContext.type == TransferType::Pull)) + { + SizedPayloadContainer container = {}; + + container.CreatePayload(Result::Aborted); + Result transferResult = SendTransferPayload(container); + if (transferResult == Result::Success) + { + // Discard all messages until we find the sentinel. + while ((transferResult == Result::Success) && + (container.GetPayload().command != TransferMessage::TransferDataSentinel)) + { + transferResult = ReceiveTransferPayload(&container); + } + + if ((transferResult == Result::Success) && + (container.GetPayload().command == TransferMessage::TransferDataSentinel)) + { + // We've successfully aborted the transfer. + const Result finalResult = container.GetPayload().result; + // We've either reached the original sentinel that indicates the end of the transfer or we've + // received a sentinel in response to calling abort. Sanity check the results with an assert. + DD_ASSERT((finalResult == Result::Aborted) || + (finalResult == Result::Success)); + DD_UNUSED(finalResult); + + m_transferContext.state = TransferState::Idle; + result = Result::Success; + } + } + } + + if (result != Result::Success) + { + m_transferContext.state = TransferState::Error; + } + + return result; + } + + // ============================================================================================================ + void TransferClient::ResetState() + { + memset(&m_transferContext, 0, sizeof(m_transferContext)); + } + + // ============================================================================================================ + // Helper method to send a payload, handling backwards compatibility and retrying. + Result TransferClient::SendTransferPayload( + const SizedPayloadContainer& container, + uint32 timeoutInMs, + uint32 retryInMs) + { + // Use the legacy size for the container if we're connected to an older client, otherwise use the real size. + const Version sessionVersion = (m_pSession.IsNull() == false) ? m_pSession->GetVersion() : 0; + const uint32 payloadSize = (sessionVersion >= TRANSFER_REFACTOR_VERSION) ? container.payloadSize : kMaxPayloadSizeInBytes; + + return SendSizedPayload(container.payload, + payloadSize, + timeoutInMs, + retryInMs); + } + + // ============================================================================================================ + // Helper method to handle sending a payload from a SizedPayloadContainer, including retrying if busy. + Result TransferClient::ReceiveTransferPayload( + SizedPayloadContainer* pContainer, + uint32 timeoutInMs, + uint32 retryInMs) + { + return ReceiveSizedPayload(pContainer->payload, + sizeof(pContainer->payload), + &pContainer->payloadSize, + timeoutInMs, + retryInMs); + } + + // ============================================================================================================ + // Helper method to send and then receive using a SizedPayloadContainer object. + Result TransferClient::TransactTransferPayload( + SizedPayloadContainer* pContainer, + uint32 timeoutInMs, + uint32 retryInMs) + { + Result result = SendTransferPayload(*pContainer, timeoutInMs, retryInMs); + if (result == Result::Success) + { + result = ReceiveTransferPayload(pContainer, timeoutInMs, retryInMs); + } + return result; + } + } + +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/ddTransferServer.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/ddTransferServer.cpp new file mode 100644 index 000000000..5dbe028aa --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/ddTransferServer.cpp @@ -0,0 +1,516 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "protocols/ddTransferServer.h" +#include "ddTransferManager.h" +#include "msgChannel.h" + +#define TRANSFER_SERVER_MIN_MAJOR_VERSION 1 +#define TRANSFER_SERVER_MAX_MAJOR_VERSION 2 + +namespace DevDriver +{ + namespace TransferProtocol + { + enum class SessionState + { + Idle = 0, + SendPayload, + StartPullTransfer, + ProcessPullTransfer, + StartPushTransfer, + ReceivePushTransferData, + }; + + class TransferServer::TransferSession + { + public: + // ======================================================================================================== + TransferSession(TransferManager* pTransferManager, const SharedPointer& pSession) + : m_scratchPayload() + , m_pTransferManager(pTransferManager) + , m_pSession(pSession) + , m_pBlock() + , m_totalBytes(0) + , m_bytesTransferred(0) + , m_crc32(0) + , m_state(SessionState::Idle) + { + } + + // ======================================================================================================== + ~TransferSession() + { + // If we're terminating a session with a valid block, then that means the transfer did not finish properly. + // Make sure to notify the block that the transfer is now ending so we don't throw off the internal counter. + if (m_pBlock.IsNull() == false) + { + m_pBlock->EndTransfer(); + } + } + + // Helper functions for working with SizedPayloadContainers and managing back-compat. + + // ======================================================================================================== + Result SendPayload(const SizedPayloadContainer& payload, uint32 timeoutInMs) + { + // If we're running an older transfer version, always write the fixed container size. + // Otherwise, write the real size. + const uint32 payloadSize = + (m_pSession->GetVersion() >= TRANSFER_REFACTOR_VERSION) ? payload.payloadSize : kMaxPayloadSizeInBytes; + + return m_pSession->Send(payloadSize, payload.payload, timeoutInMs); + } + + // ======================================================================================================== + Result ReceivePayload(SizedPayloadContainer* pPayload, uint32 timeoutInMs) + { + DD_ASSERT(pPayload != nullptr); + return m_pSession->Receive(sizeof(pPayload->payload), pPayload->payload, &pPayload->payloadSize, timeoutInMs); + } + + // ======================================================================================================== + void ProcessPayload() + { + DD_ASSERT(m_state == SessionState::Idle); + + switch (m_scratchPayload.GetPayload().command) + { + case TransferMessage::TransferRequest: + { + const TransferRequest request = m_scratchPayload.GetPayload(); + + switch (request.type) + { + // It is invalid for sessions of version less than TRANSFER_REFACTOR_VERSION to set a non-zero + // value for request.type + case TransferType::Pull: + { + // Determine if the requested block is available. Available, in this context, means that + // the block exists and has been closed. + // If the block is available, start the transfer process. + // If the block is not available, return an error response. + SharedPointer pBlock = m_pTransferManager->GetServerBlock(request.blockId); + const bool blockIsAvailable = (!pBlock.IsNull() && pBlock->IsClosed()); + if (blockIsAvailable && (m_state == SessionState::Idle)) + { + // Increments the number of pending transfers to prevent the block from being destroyed + // in the middle of a transfer. + pBlock->BeginTransfer(); + + // Use the block information to populate our transfer context. + m_pBlock = pBlock; + m_totalBytes = pBlock->GetBlockDataSize(); + m_bytesTransferred = 0; + m_crc32 = pBlock->GetCrc32(); + m_state = SessionState::StartPullTransfer; + + const uint32 blockSizeInBytes = static_cast(m_pBlock->GetBlockDataSize()); + if (m_pSession->GetVersion() >= TRANSFER_REFACTOR_VERSION) + { + m_scratchPayload.CreatePayload(blockSizeInBytes); + } + else + { + m_scratchPayload.CreatePayload(Result::Success, blockSizeInBytes); + } + + SendPullTransferHeader(); + } + else + { + m_scratchPayload.CreatePayload(Result::Error); + m_state = SessionState::SendPayload; + SendScratchPayloadAndMoveToIdle(); + } + break; + } + case TransferType::Push: + { + DD_ASSERT(m_pSession->GetVersion() >= TRANSFER_REFACTOR_VERSION); + // Determine if the requested block is available. Available, in this context, means that + // the block exists and has not been closed yet. + // If the block is available, start the transfer process. + // If the block is not available, return an error response. + SharedPointer pBlock = m_pTransferManager->GetServerBlock(request.blockId); + const bool blockIsAvailable = (!pBlock.IsNull() && !pBlock->IsClosed()); + if (blockIsAvailable && (m_state == SessionState::Idle)) + { + // Increments the number of pending transfers to prevent the block from being destroyed + // in the middle of a transfer. + pBlock->BeginTransfer(); + + // Increments the number of pending transfers to prevent the block from being destroyed + // in the middle of a transfer. + m_pBlock = pBlock; + m_bytesTransferred = 0; + m_crc32 = 0; + + m_totalBytes = request.sizeInBytes; + if (m_totalBytes > 0) + { + m_pBlock->Reserve(m_totalBytes); + m_state = SessionState::StartPushTransfer; + m_scratchPayload.CreatePayload(Result::Success); + StartPushTransferSession(); + } + else + { + m_state = SessionState::SendPayload; + m_scratchPayload.CreatePayload(Result::Error); + SendScratchPayloadAndMoveToIdle(); + } + } + else + { + m_scratchPayload.CreatePayload(Result::Error); + m_state = SessionState::SendPayload; + SendScratchPayloadAndMoveToIdle(); + } + break; + } + default: + { + m_scratchPayload.CreatePayload(Result::Error); + m_state = SessionState::SendPayload; + SendScratchPayloadAndMoveToIdle(); + break; + } + } + break; + } + + case TransferMessage::TransferStatus: + { + DD_ALERT(m_scratchPayload.GetPayload().result == Result::Aborted); + // It's possible that we may receive a transfer abort request after we've already sent + // all the transfer data to the remote client successfully. This can happen when the + // remaining amount of data for the transfer fits into the entire send window. + // In this case, we still need to respond correctly and send the client an abort sentinel. + SendSentinel(Result::Aborted); + break; + } + + default: + { + // Invalid command + DD_UNREACHABLE(); + break; + } + } + } + + // ======================================================================================================== + void SendScratchPayloadAndMoveToIdle() + { + DD_ASSERT(m_state == SessionState::SendPayload); + if (SendPayload(m_scratchPayload, kNoWait) == Result::Success) + { + m_state = SessionState::Idle; + } + } + + // ======================================================================================================== + void SendSentinel(Result status, uint32 crc32 = 0) + { + m_scratchPayload.CreatePayload(status, crc32); + m_state = SessionState::SendPayload; + SendScratchPayloadAndMoveToIdle(); + } + + // ======================================================================================================== + void ProcessPullSession() + { + DD_ASSERT(m_state == SessionState::ProcessPullTransfer); + + // Look for an abort request. + const Result result = ReceivePayload(&m_scratchPayload, kNoWait); + + // If we haven't received any messages from the client, then continue transferring data to them. + if (result == Result::NotReady) + { + while (m_bytesTransferred < m_totalBytes) + { + const uint8* pData = (m_pBlock->GetBlockData() + m_bytesTransferred); + const size_t bytesRemaining = (m_totalBytes - m_bytesTransferred); + const size_t bytesToSend = Platform::Min(kMaxTransferDataChunkSize, bytesRemaining); + + TransferDataChunk::WritePayload(pData, bytesToSend, &m_scratchPayload); + + const Result sendResult = SendPayload(m_scratchPayload, kNoWait); + if (sendResult == Result::Success) + { + m_bytesTransferred += bytesToSend; + } + else + { + break; + } + } + + // If we've finished transferring all block data, send the sentinel and free the block. + if (m_bytesTransferred == m_totalBytes) + { + // Notify the block that a transfer is completing. + m_pBlock->EndTransfer(); + m_pBlock.Clear(); + SendSentinel(Result::Success, m_crc32); + } + } + else if (result == Result::Success) + { + if (m_scratchPayload.GetPayload().command == TransferMessage::TransferStatus) + { + // This should only be received for an abort + DD_ALERT(m_scratchPayload.GetPayload().result == Result::Aborted); + SendSentinel(Result::Aborted); + } + else + { + // We should only ever receive abort requests in this state. Send back an error. + SendSentinel(Result::Error); + DD_ALERT_REASON("Invalid response received"); + } + } + else + { + // We've encountered an error while receiving. Do nothing. The session will close itself soon. + } + } + + // ======================================================================================================== + void SendPullTransferHeader() + { + DD_ASSERT(m_state == SessionState::StartPullTransfer); + if (SendPayload(m_scratchPayload, kNoWait) == Result::Success) + { + m_state = SessionState::ProcessPullTransfer; + ProcessPullSession(); + } + } + + // ======================================================================================================== + void StartPushTransferSession() + { + DD_ASSERT(m_pSession->GetVersion() >= TRANSFER_REFACTOR_VERSION); + DD_ASSERT(m_state == SessionState::StartPushTransfer); + if (SendPayload(m_scratchPayload, kNoWait) == Result::Success) + { + m_state = SessionState::ReceivePushTransferData; + } + } + + // ======================================================================================================== + void ReceivePushTransferData() + { + DD_ASSERT(m_state == SessionState::ReceivePushTransferData); + DD_ASSERT(m_pSession->GetVersion() >= TRANSFER_REFACTOR_VERSION); + Result result = Result::Success; + do + { + result = ReceivePayload(&m_scratchPayload, kNoWait); + if (result == Result::Success) + { + switch (m_scratchPayload.GetPayload().command) + { + case TransferMessage::TransferDataChunk: + { + if (m_bytesTransferred < m_totalBytes) + { + const size_t bytesRemaining = (m_totalBytes - m_bytesTransferred); + const size_t numBytes = m_scratchPayload.payloadSize - offsetof(TransferDataChunk, data); + const size_t bytesToWrite = Platform::Min(numBytes, bytesRemaining); + m_pBlock->Write(&m_scratchPayload.GetPayload().data[0], bytesToWrite); + m_bytesTransferred += bytesToWrite; + } + else + { + DD_ALERT_REASON("Client tried to write more than requested bytes to the server"); + CancelTransfer(Result::InsufficientMemory); + } + break; + } + case TransferMessage::TransferDataSentinel: + { + const TransferDataSentinel& sentinel = m_scratchPayload.GetPayload(); + if ((sentinel.result == Result::Success) && (m_pBlock->GetCrc32() == sentinel.crc32)) + { + m_pBlock->Close(); + m_pBlock->EndTransfer(); + m_pBlock.Clear(); + // Transfer succeeded + m_state = SessionState::SendPayload; + m_scratchPayload.CreatePayload(Result::Success); + SendScratchPayloadAndMoveToIdle(); + } + else + { + const Result abortReason = (sentinel.result != Result::Aborted) ? Result::Error : Result::Aborted; + CancelTransfer(abortReason); + } + break; + } + default: + { + DD_ALERT("Push transfer received unexpected packet from client"); + CancelTransfer(Result::Error); + break; + } + } + } + } while ((result == Result::Success) && (m_state == SessionState::ReceivePushTransferData)); + } + + // ======================================================================================================== + void CancelTransfer(Result reason) + { + if (!m_pBlock.IsNull()) + { + m_pBlock->Reset(); + m_pBlock->EndTransfer(); + m_pBlock.Clear(); + } + m_state = SessionState::SendPayload; + m_scratchPayload.CreatePayload(reason); + SendScratchPayloadAndMoveToIdle(); + } + + // ======================================================================================================== + void UpdateSession() + { + // Identify which state the session is currently in and perform associated update. + switch (m_state) + { + case SessionState::Idle: + { + const Result result = ReceivePayload(&m_scratchPayload, kNoWait); + if (result == Result::Success) + { + ProcessPayload(); + } + break; + } + + case SessionState::ProcessPullTransfer: + { + ProcessPullSession(); + break; + } + case SessionState::StartPullTransfer: + { + SendPullTransferHeader(); + break; + } + + case SessionState::StartPushTransfer: + { + StartPushTransferSession(); + break; + } + + case SessionState::ReceivePushTransferData: + { + ReceivePushTransferData(); + break; + } + + case SessionState::SendPayload: + { + SendScratchPayloadAndMoveToIdle(); + break; + } + + default: + { + DD_UNREACHABLE(); + break; + } + } + } + + private: + SizedPayloadContainer m_scratchPayload; + TransferManager* m_pTransferManager; + SharedPointer m_pSession; + SharedPointer m_pBlock; + size_t m_totalBytes; + size_t m_bytesTransferred; + uint32 m_crc32; + SessionState m_state; + }; + + // ===================================================================================================================== + TransferServer::TransferServer(IMsgChannel* pMsgChannel, TransferManager* pTransferManager) + : BaseProtocolServer(pMsgChannel, Protocol::Transfer, TRANSFER_SERVER_MIN_MAJOR_VERSION, TRANSFER_SERVER_MAX_MAJOR_VERSION) + , m_pTransferManager(pTransferManager) + { + DD_ASSERT(m_pMsgChannel != nullptr); + } + + // ===================================================================================================================== + TransferServer::~TransferServer() + {} + + // ===================================================================================================================== + void TransferServer::Finalize() + { + BaseProtocolServer::Finalize(); + } + + // ===================================================================================================================== + bool TransferServer::AcceptSession(const SharedPointer& pSession) + { + DD_UNUSED(pSession); + return true; + } + + // ===================================================================================================================== + void TransferServer::SessionEstablished(const SharedPointer& pSession) + { + // Allocate session data for the newly established session + TransferSession* pSessionData = DD_NEW(TransferSession, m_pMsgChannel->GetAllocCb())(m_pTransferManager, pSession); + pSession->SetUserData(pSessionData); + } + + // ===================================================================================================================== + void TransferServer::UpdateSession(const SharedPointer& pSession) + { + TransferSession* pSessionData = reinterpret_cast(pSession->GetUserData()); + pSessionData->UpdateSession(); + } + + // ===================================================================================================================== + void TransferServer::SessionTerminated(const SharedPointer& pSession, Result terminationReason) + { + DD_UNUSED(terminationReason); + TransferSession* pSessionData = reinterpret_cast(pSession->SetUserData(nullptr)); + + // Free the session data + if (pSessionData != nullptr) + { + DD_DELETE(pSessionData, m_pMsgChannel->GetAllocCb()); + } + } + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/ddURIClient.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/ddURIClient.cpp new file mode 100644 index 000000000..8f742482e --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/ddURIClient.cpp @@ -0,0 +1,231 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "protocols/ddURIClient.h" +#include "protocols/ddURIProtocol.h" +#include "msgChannel.h" +#include "ddTransferManager.h" + +#define URI_CLIENT_MIN_MAJOR_VERSION URI_INITIAL_VERSION +#define URI_CLIENT_MAX_MAJOR_VERSION URI_RESPONSE_FORMATS_VERSION + +namespace DevDriver +{ + namespace URIProtocol + { + static constexpr URIDataFormat ResponseFormatToUriFormat(ResponseDataFormat format) + { + static_assert(static_cast(ResponseDataFormat::Unknown) == static_cast(URIDataFormat::Unknown), + "ResponseDataFormat and URIDataFormat no longer match"); + static_assert(static_cast(ResponseDataFormat::Text) == static_cast(URIDataFormat::Text), + "ResponseDataFormat and URIDataFormat no longer match"); + static_assert(static_cast(ResponseDataFormat::Binary) == static_cast(URIDataFormat::Binary), + "ResponseDataFormat and URIDataFormat no longer match"); + static_assert(static_cast(ResponseDataFormat::Count) == static_cast(URIDataFormat::Count), + "ResponseDataFormat and URIDataFormat no longer match"); + return static_cast(format); + } + + // ===================================================================================================================== + URIClient::URIClient(IMsgChannel* pMsgChannel) + : BaseProtocolClient(pMsgChannel, Protocol::URI, URI_CLIENT_MIN_MAJOR_VERSION, URI_CLIENT_MAX_MAJOR_VERSION) + { + memset(&m_context, 0, sizeof(m_context)); + } + + // ===================================================================================================================== + URIClient::~URIClient() + { + } + + // ===================================================================================================================== + Result URIClient::RequestURI( + const char* pRequestString, + ResponseHeader* pResponseHeader) + { + Result result = Result::Error; + + if ((m_context.state == State::Idle) && + (pRequestString != nullptr)) + { + // Set up the request payload. + URIPayload payload = {}; + payload.command = URIMessage::URIRequest; + Platform::Strncpy(payload.uriRequest.uriString, pRequestString, sizeof(payload.uriRequest.uriString)); + + // Issue a transaction. + result = Transact(payload, payload); + if ((result == Result::Success) && (payload.command == URIMessage::URIResponse)) + { + // Set up some defaults for the response fields. + URIDataFormat responseDataFormat = URIDataFormat::Text; + + // We've successfully received the response. Extract the relevant fields from the response. + const URIResponsePayload& responsePayload = payload.uriResponse; + const TransferProtocol::BlockId remoteBlockId = responsePayload.blockId; + result = responsePayload.result; + + if (m_pSession->GetVersion() >= URI_RESPONSE_FORMATS_VERSION) + { + responseDataFormat = ResponseFormatToUriFormat(responsePayload.format); + } + + if (result == Result::Success) + { + // Attempt to open the pull block containing the response data. + // @Todo: Detect if the service returns the invalid block ID and treat that as a success. + // It will require a new protocol version because existing clients will fail if + // the invalid block ID is returned in lieu of a block of size 0. + TransferProtocol::PullBlock* pPullBlock = + m_pMsgChannel->GetTransferManager().OpenPullBlock(GetRemoteClientId(), remoteBlockId); + + if (pPullBlock != nullptr) + { + m_context.pBlock = pPullBlock; + const size_t blockSize = m_context.pBlock->GetBlockDataSize(); + + // We successfully opened the block. Return the block data size and format via the header. + // The header is optional so check for nullptr first. + if (pResponseHeader != nullptr) + { + pResponseHeader->responseDataSizeInBytes = blockSize; + pResponseHeader->responseDataFormat = responseDataFormat; + } + + // If the block size is non-zero we move to the read state + if (blockSize > 0) + { + // Set up internal state. + m_context.state = State::ReadResponse; + } + else // If the block size is zero we automatically close it and move back to idle + { + // @Todo: Pass the invalid block ID back instead of a zero sized block. + m_context.state = State::Idle; + m_pMsgChannel->GetTransferManager().ClosePullBlock(&m_context.pBlock); + } + } + else + { + // Failed to open the response block. + result = Result::Error; + } + } + else if (result == Result::Unavailable) + { + // The request failed because the requested service was not available on the remote server. + } + else + { + // The request failed on the remote server for an unknown reason. + result = Result::Error; + } + } + else + { + // If we fail the transaction or it's an unexpected response, fail the request. + result = Result::Error; + } + } + + return result; + } + +#if !DD_VERSION_SUPPORTS(GPUOPEN_URI_RESPONSE_FORMATS_VERSION) + // ===================================================================================================================== + Result URIClient::RequestURI( + const char* pRequestString, + size_t* pResponseSizeInBytes) + { + Result result = Result::Error; + + if ((pRequestString != nullptr) && + (pResponseSizeInBytes != nullptr)) + { + // Pass a header into the request function so we can get the response size. + ResponseHeader header = {}; + result = RequestURI(pRequestString, &header); + + // If the request was successful, extract the response size and return it. + if (result == Result::Success) + { + *pResponseSizeInBytes = header.responseDataSizeInBytes; + } + } + + return result; + } +#endif + + // ===================================================================================================================== + Result URIClient::ReadResponse(uint8* pDstBuffer, size_t bufferSize, size_t* pBytesRead) + { + Result result = Result::Error; + + if (m_context.state == State::ReadResponse) + { + result = m_context.pBlock->Read(pDstBuffer, bufferSize, pBytesRead); + + // If we reach the end of the stream or we encounter an error, we should transition back to the idle state. + if ((result == Result::EndOfStream) || + (result == Result::Error)) + { + m_context.state = State::Idle; + m_pMsgChannel->GetTransferManager().ClosePullBlock(&m_context.pBlock); + } + } + + return result; + } + + // ===================================================================================================================== + Result URIClient::AbortRequest() + { + Result result = Result::Error; + + if (m_context.state == State::ReadResponse) + { + m_context.state = State::Idle; + m_pMsgChannel->GetTransferManager().ClosePullBlock(&m_context.pBlock); + + result = Result::Success; + } + + return result; + } + + // ===================================================================================================================== + void URIClient::ResetState() + { + // Close the pull block if it's still valid. + if (m_context.pBlock != nullptr) + { + m_pMsgChannel->GetTransferManager().ClosePullBlock(&m_context.pBlock); + } + + memset(&m_context, 0, sizeof(m_context)); + } + } + +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/ddURIServer.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/ddURIServer.cpp new file mode 100644 index 000000000..0835378a4 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/ddURIServer.cpp @@ -0,0 +1,314 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "ddURIServer.h" +#include "msgChannel.h" +#include "ddTransferManager.h" +#include "protocols/ddURIProtocol.h" + +#define URI_SERVER_MIN_MAJOR_VERSION URI_INITIAL_VERSION +#define URI_SERVER_MAX_MAJOR_VERSION URI_RESPONSE_FORMATS_VERSION + +namespace DevDriver +{ + namespace URIProtocol + { + static constexpr ResponseDataFormat UriFormatToResponseFormat(URIDataFormat format) + { + static_assert(static_cast(ResponseDataFormat::Unknown) == static_cast(URIDataFormat::Unknown), + "ResponseDataFormat and URIDataFormat no longer match"); + static_assert(static_cast(ResponseDataFormat::Text) == static_cast(URIDataFormat::Text), + "ResponseDataFormat and URIDataFormat no longer match"); + static_assert(static_cast(ResponseDataFormat::Binary) == static_cast(URIDataFormat::Binary), + "ResponseDataFormat and URIDataFormat no longer match"); + static_assert(static_cast(ResponseDataFormat::Count) == static_cast(URIDataFormat::Count), + "ResponseDataFormat and URIDataFormat no longer match"); + return static_cast(format); + } + + struct URISession + { + Version version; + SharedPointer pBlock; + URIPayload payload; + bool hasQueuedPayload; + + explicit URISession() + : version(0) + , hasQueuedPayload(false) + { + memset(&payload, 0, sizeof(payload)); + } + }; + + // ===================================================================================================================== + // Parses out the parameters from a request string. (Ex. service://service-args) + bool ExtractRequestParameters(char* pRequestString, char** ppServiceName, char** ppServiceArguments) + { + DD_ASSERT(pRequestString != nullptr); + DD_ASSERT(ppServiceName != nullptr); + DD_ASSERT(ppServiceArguments != nullptr); + + bool result = false; + + // Iterate through the null terminated string until we find the ":" character or the end of the string. + char* pCurrentChar = pRequestString; + while ((*pCurrentChar != ':') && (*pCurrentChar != 0)) + { + ++pCurrentChar; + } + + // If we haven't reached the end of the string then we've found the ":" character. + // Otherwise this string isn't formatted correctly. + if (*pCurrentChar != 0) + { + // Overwrite the ":" character in memory with a null byte to allow us to divide up the request string + // in place. + *pCurrentChar = 0; + + // Return the service name and arguments out of the modified request string. + *ppServiceName = pRequestString; + *ppServiceArguments = pCurrentChar + 3; + + result = true; + } + + return result; + } + + // ===================================================================================================================== + URIServer::URIServer(IMsgChannel* pMsgChannel) + : BaseProtocolServer(pMsgChannel, Protocol::URI, URI_SERVER_MIN_MAJOR_VERSION, URI_SERVER_MAX_MAJOR_VERSION) + , m_registeredServices(pMsgChannel->GetAllocCb()) + { + DD_ASSERT(m_pMsgChannel != nullptr); + } + + // ===================================================================================================================== + URIServer::~URIServer() + { + } + + // ===================================================================================================================== + void URIServer::Finalize() + { + Platform::LockGuard lock(m_mutex); + BaseProtocolServer::Finalize(); + } + + // ===================================================================================================================== + bool URIServer::AcceptSession(const SharedPointer& pSession) + { + DD_UNUSED(pSession); + return true; + } + + // ===================================================================================================================== + void URIServer::SessionEstablished(const SharedPointer& pSession) + { + DD_UNUSED(pSession); + + // Allocate session data for the newly established session + URISession* pSessionData = DD_NEW(URISession, m_pMsgChannel->GetAllocCb())(); + + // Allocate a server block for use by the session. + pSessionData->pBlock = m_pMsgChannel->GetTransferManager().OpenServerBlock(); + + pSession->SetUserData(pSessionData); + } + + // ===================================================================================================================== + void URIServer::UpdateSession(const SharedPointer& pSession) + { + URISession* pSessionData = reinterpret_cast(pSession->GetUserData()); + + // Attempt to send the session's queued payload if it has one. + if (pSessionData->hasQueuedPayload) + { + Result result = pSession->Send(sizeof(pSessionData->payload), &pSessionData->payload, kNoWait); + if (result == Result::Success) + { + // We successfully sent the payload. The session can now handle new requests. + pSessionData->hasQueuedPayload = false; + } + } + + // We can only receive new messages if we don't currently have a queued payload. + if (!pSessionData->hasQueuedPayload) + { + // Receive and handle any new requests. + uint32 bytesReceived = 0; + Result result = pSession->Receive(sizeof(pSessionData->payload), &pSessionData->payload, &bytesReceived, kNoWait); + + if (result == Result::Success) + { + // Make sure we receive a correctly sized payload. + DD_ASSERT(sizeof(pSessionData->payload) == bytesReceived); + + // Make sure the payload is a uri request since it's the only payload type we should ever receive. + DD_ASSERT(pSessionData->payload.command == URIMessage::URIRequest); + + // Reset the block associated with the session so we can write new data into it. + pSessionData->pBlock->Reset(); + + // Attempt to extract the request string. + char* pRequestString = pSessionData->payload.uriRequest.uriString; + char* pServiceName = nullptr; + char* pServiceArguments = nullptr; + result = ExtractRequestParameters(pRequestString, &pServiceName, &pServiceArguments) ? Result::Success : Result::Error; + + if (result == Result::Success) + { + // We've successfully extracted the request parameters. + // Lock the mutex and look up the requested service if it's available. + m_mutex.Lock(); + + IService* pService = FindService(pServiceName); + + m_mutex.Unlock(); + + // Check if the requested service was successfully located. + if (pService != nullptr) + { + // Handle the request using the appropriate service. + URIRequestContext context = {}; + context.pRequestArguments = pServiceArguments; + context.pResponseBlock = pSessionData->pBlock; + context.responseDataFormat = URIDataFormat::Unknown; + + result = pService->HandleRequest(&context); + + // Close the response block. + pSessionData->pBlock->Close(); + + // Assemble the response payload. + pSessionData->payload.command = URIMessage::URIResponse; + // Return the block id and associate the block with the session if we successfully handled the request. + pSessionData->payload.uriResponse.result = result; + pSessionData->payload.uriResponse.blockId = ((result == Result::Success) ? pSessionData->pBlock->GetBlockId() + : TransferProtocol::kInvalidBlockId); + // We send this data back regardless of protocol version, but it will only be read + // in a v2 session. + pSessionData->payload.uriResponse.format = UriFormatToResponseFormat(context.responseDataFormat); + + // Mark the session as having a queued payload if we fail to send the response. + if (pSession->Send(sizeof(pSessionData->payload), &pSessionData->payload, kNoWait) != Result::Success) + { + pSessionData->hasQueuedPayload = true; + } + } + else + { + // Failed to locate appropriate service. + + // Assemble the response payload. + pSessionData->payload.command = URIMessage::URIResponse; + pSessionData->payload.uriResponse.result = Result::Unavailable; + pSessionData->payload.uriResponse.blockId = TransferProtocol::kInvalidBlockId; + pSessionData->payload.uriResponse.format = ResponseDataFormat::Unknown; + + // Mark the session as having a queued payload if we fail to send the response. + if (pSession->Send(sizeof(pSessionData->payload), &pSessionData->payload, kNoWait) != Result::Success) + { + pSessionData->hasQueuedPayload = true; + } + } + } + else + { + // Failed to parse request parameters. + + // Assemble the response payload. + pSessionData->payload.command = URIMessage::URIResponse; + pSessionData->payload.uriResponse.result = Result::Error; + pSessionData->payload.uriResponse.blockId = TransferProtocol::kInvalidBlockId; + pSessionData->payload.uriResponse.format = ResponseDataFormat::Unknown; + + // Mark the session as having a queued payload if we fail to send the response. + if (pSession->Send(sizeof(pSessionData->payload), &pSessionData->payload, kNoWait) != Result::Success) + { + pSessionData->hasQueuedPayload = true; + } + } + } + } + } + + // ===================================================================================================================== + void URIServer::SessionTerminated(const SharedPointer& pSession, Result terminationReason) + { + DD_UNUSED(terminationReason); + URISession *pURISession = reinterpret_cast(pSession->SetUserData(nullptr)); + + // Free the session data + if (pURISession != nullptr) + { + // Release the session's server block before destroying it. + if (!pURISession->pBlock.IsNull()) + { + m_pMsgChannel->GetTransferManager().CloseServerBlock(pURISession->pBlock); + } + + DD_DELETE(pURISession, m_pMsgChannel->GetAllocCb()); + } + } + + // ===================================================================================================================== + Result URIServer::RegisterService(IService* pService) + { + Platform::LockGuard lock(m_mutex); + + const Result result = m_registeredServices.PushBack(pService) ? Result::Success : Result::Error; + + return result; + } + + // ===================================================================================================================== + Result URIServer::UnregisterService(IService* pService) + { + Platform::LockGuard lock(m_mutex); + + const Result result = m_registeredServices.Remove(pService) ? Result::Success : Result::Error; + + return result; + } + + // ===================================================================================================================== + IService* URIServer::FindService(const char* pServiceName) + { + IService* pService = nullptr; + + for (size_t serviceIndex = 0; serviceIndex < m_registeredServices.Size(); ++serviceIndex) + { + if (strcmp(m_registeredServices[serviceIndex]->GetName(), pServiceName) == 0) + { + pService = m_registeredServices[serviceIndex]; + break; + } + } + + return pService; + } + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/ddURIServer.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/ddURIServer.h new file mode 100644 index 000000000..cd1c54a9f --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/ddURIServer.h @@ -0,0 +1,75 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file ddURIServer.h +* @brief Class declaration for URIServer. +*********************************************************************************************************************** +*/ + +#pragma once + +#include "baseProtocolServer.h" +#include "util/vector.h" +#include "ddUriInterface.h" + +namespace DevDriver +{ + namespace URIProtocol + { + + // The protocol server implementation for the uri protocol. + class URIServer : public BaseProtocolServer + { + public: + explicit URIServer(IMsgChannel* pMsgChannel); + ~URIServer(); + + void Finalize() override; + + bool AcceptSession(const SharedPointer& pSession) override; + void SessionEstablished(const SharedPointer& pSession) override; + void UpdateSession(const SharedPointer& pSession) override; + void SessionTerminated(const SharedPointer& pSession, Result terminationReason) override; + + // Adds a service to the list of registered server. + Result RegisterService(IService* pService); + + // Removes a service from the list of registered server. + Result UnregisterService(IService* pService); + + private: + // Returns a pointer to a service that was registered with a name that matches pServiceName. + // Returns nullptr if there is no service registered with a matching name. + IService* FindService(const char* pServiceName); + + // Mutex used for synchronizing the registered services list. + Platform::Mutex m_mutex; + + // A list of all the registered services. + // @todo: Replace this vector with a map. + Vector m_registeredServices; + }; + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/driverControlClient.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/driverControlClient.cpp new file mode 100644 index 000000000..99e90320b --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/driverControlClient.cpp @@ -0,0 +1,401 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "protocols/driverControlClient.h" +#include "msgChannel.h" + +#define DRIVERCONTROL_CLIENT_MIN_MAJOR_VERSION 1 +#define DRIVERCONTROL_CLIENT_MAX_MAJOR_VERSION 2 + +namespace DevDriver +{ + namespace DriverControlProtocol + { + DriverControlClient::DriverControlClient(IMsgChannel* pMsgChannel) + : BaseProtocolClient(pMsgChannel, Protocol::DriverControl, DRIVERCONTROL_CLIENT_MIN_MAJOR_VERSION, DRIVERCONTROL_CLIENT_MAX_MAJOR_VERSION) + { + } + + DriverControlClient::~DriverControlClient() + { + } + + Result DriverControlClient::PauseDriver() + { + Result result = Result::Error; + + if (IsConnected()) + { + DriverControlPayload payload = {}; + payload.command = DriverControlMessage::PauseDriverRequest; + + result = SendPayload(payload); + if (result == Result::Success) + { + result = ReceivePayload(payload); + if (result == Result::Success) + { + if (payload.command == DriverControlMessage::PauseDriverResponse) + { + result = payload.pauseDriverResponse.result; + } + else + { + // Invalid response payload + result = Result::Error; + } + } + } + } + + return result; + } + + Result DriverControlClient::ResumeDriver() + { + Result result = Result::Error; + + if (IsConnected()) + { + DriverControlPayload payload = {}; + payload.command = DriverControlMessage::ResumeDriverRequest; + + result = SendPayload(payload); + if (result == Result::Success) + { + result = ReceivePayload(payload); + if (result == Result::Success) + { + if (payload.command == DriverControlMessage::ResumeDriverResponse) + { + result = payload.resumeDriverResponse.result; + } + else + { + // Invalid response payload + result = Result::Error; + } + } + } + } + + return result; + } + + Result DriverControlClient::StepDriver(uint32 numSteps) + { + Result result = Result::Error; + + if (IsConnected() && numSteps > 0) + { + DriverControlPayload payload = {}; + payload.command = DriverControlMessage::StepDriverRequest; + payload.stepDriverRequest.count = numSteps; + result = SendPayload(payload); + if (result == Result::Success) + { + result = ReceivePayload(payload); + if (result == Result::Success) + { + if (payload.command == DriverControlMessage::StepDriverResponse) + { + result = payload.resumeDriverResponse.result; + } + else + { + // Invalid response payload + result = Result::Error; + } + } + } + } + + return result; + } + + Result DriverControlClient::QueryNumGpus(uint32* pNumGpus) + { + Result result = Result::Error; + + if (IsConnected() && (pNumGpus != nullptr)) + { + DriverControlPayload payload = {}; + payload.command = DriverControlMessage::QueryNumGpusRequest; + + result = SendPayload(payload); + if (result == Result::Success) + { + result = ReceivePayload(payload); + if (result == Result::Success) + { + if (payload.command == DriverControlMessage::QueryNumGpusResponse) + { + result = payload.queryNumGpusResponse.result; + *pNumGpus = payload.queryNumGpusResponse.numGpus; + } + else + { + // Invalid response payload + result = Result::Error; + } + } + } + } + + return result; + } + + Result DriverControlClient::QueryDeviceClockMode(uint32 gpuIndex, DeviceClockMode* pClockMode) + { + Result result = Result::Error; + + if (IsConnected() && (pClockMode != nullptr)) + { + DriverControlPayload payload = {}; + payload.command = DriverControlMessage::QueryDeviceClockModeRequest; + payload.queryDeviceClockModeRequest.gpuIndex = gpuIndex; + + result = SendPayload(payload); + if (result == Result::Success) + { + result = ReceivePayload(payload); + if (result == Result::Success) + { + if (payload.command == DriverControlMessage::QueryDeviceClockModeResponse) + { + result = payload.queryDeviceClockModeResponse.result; + if (result == Result::Success) + { + *pClockMode = payload.queryDeviceClockModeResponse.mode; + } + } + else + { + // Invalid response payload + result = Result::Error; + } + } + } + } + + return result; + } + + Result DriverControlClient::SetDeviceClockMode(uint32 gpuIndex, DeviceClockMode clockMode) + { + Result result = Result::Error; + + if (IsConnected()) + { + DriverControlPayload payload = {}; + payload.command = DriverControlMessage::SetDeviceClockModeRequest; + payload.setDeviceClockModeRequest.mode = clockMode; + payload.setDeviceClockModeRequest.gpuIndex = gpuIndex; + + result = SendPayload(payload); + if (result == Result::Success) + { + result = ReceivePayload(payload); + if (result == Result::Success) + { + if (payload.command == DriverControlMessage::SetDeviceClockModeResponse) + { + result = payload.setDeviceClockModeResponse.result; + } + else + { + // Invalid response payload + result = Result::Error; + } + } + } + } + + return result; + } + + Result DriverControlClient::QueryDeviceClock(uint32 gpuIndex, float* pGpuClock, float* pMemClock) + { + Result result = Result::Error; + + if (IsConnected() && (pGpuClock != nullptr) && (pMemClock != nullptr)) + { + DriverControlPayload payload = {}; + payload.command = DriverControlMessage::QueryDeviceClockRequest; + payload.queryDeviceClockRequest.gpuIndex = gpuIndex; + + result = SendPayload(payload); + if (result == Result::Success) + { + result = ReceivePayload(payload); + if (result == Result::Success) + { + if (payload.command == DriverControlMessage::QueryDeviceClockResponse) + { + result = payload.queryDeviceClockResponse.result; + if (result == Result::Success) + { + *pGpuClock = payload.queryDeviceClockResponse.gpuClock; + *pMemClock = payload.queryDeviceClockResponse.memClock; + } + } + else + { + // Invalid response payload + result = Result::Error; + } + } + } + } + + return result; + } + + Result DriverControlClient::QueryMaxDeviceClock(uint32 gpuIndex, float* pMaxGpuClock, float* pMaxMemClock) + { + Result result = Result::Error; + + if (IsConnected() && (pMaxGpuClock != nullptr) && (pMaxMemClock != nullptr)) + { + DriverControlPayload payload = {}; + payload.command = DriverControlMessage::QueryMaxDeviceClockRequest; + payload.queryMaxDeviceClockRequest.gpuIndex = gpuIndex; + + result = SendPayload(payload); + if (result == Result::Success) + { + result = ReceivePayload(payload); + if (result == Result::Success) + { + if (payload.command == DriverControlMessage::QueryMaxDeviceClockResponse) + { + result = payload.queryMaxDeviceClockResponse.result; + if (result == Result::Success) + { + *pMaxGpuClock = payload.queryMaxDeviceClockResponse.maxGpuClock; + *pMaxMemClock = payload.queryMaxDeviceClockResponse.maxMemClock; + } + } + else + { + // Invalid response payload + result = Result::Error; + } + } + } + } + + return result; + } + + Result DriverControlClient::QueryDriverStatus(DriverStatus* pDriverStatus) + { + Result result = Result::Error; + + if (IsConnected() && (pDriverStatus != nullptr)) + { + DriverControlPayload payload = {}; + payload.command = DriverControlMessage::QueryDriverStatusRequest; + + result = SendPayload(payload); + if (result == Result::Success) + { + result = ReceivePayload(payload); + if (result == Result::Success) + { + if (payload.command == DriverControlMessage::QueryDriverStatusResponse) + { + *pDriverStatus = payload.queryDriverStatusResponse.status; + } + else + { + // Invalid response payload + result = Result::Error; + } + } + } + } + + return result; + } + + Result DriverControlClient::WaitForDriverInitialization(uint32 timeoutInMs) + { + Result result = Result::VersionMismatch; + if (GetSessionVersion() >= DRIVERCONTROL_INITIALIZATION_STATUS_VERSION) + { + result = Result::Error; + if (IsConnected()) + { + const uint64 startTime = Platform::GetCurrentTimeInMs(); + const uint64 kQueryDelayInMs = 250; + uint64 nextQueryTime = startTime; + result = Result::Success; + + while (result == Result::Success) + { + const uint64 currentTime = Platform::GetCurrentTimeInMs(); + const uint64 totalElapsedTime = (currentTime - startTime); + if (totalElapsedTime >= timeoutInMs) + { + result = Result::NotReady; + } + else if (currentTime >= nextQueryTime) + { + nextQueryTime = currentTime + kQueryDelayInMs; + + DriverControlPayload payload = {}; + payload.command = DriverControlMessage::QueryDriverStatusRequest; + + result = SendPayload(payload); + if (result == Result::Success) + { + result = ReceivePayload(payload); + if (result == Result::Success) + { + if (payload.command == DriverControlMessage::QueryDriverStatusResponse) + { + if ((payload.queryDriverStatusResponse.status == DriverStatus::Running) || + (payload.queryDriverStatusResponse.status == DriverStatus::Paused)) + { + break; + } + } + else + { + // Invalid response payload + result = Result::Error; + } + } + } + } + } + } + } + + return result; + } +} + +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/driverControlServer.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/driverControlServer.cpp new file mode 100644 index 000000000..240130342 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/driverControlServer.cpp @@ -0,0 +1,594 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "protocols/driverControlServer.h" +#include "msgChannel.h" +#include +#include "protocols/systemProtocols.h" + +#define DRIVERCONTROL_SERVER_MIN_MAJOR_VERSION 1 +#define DRIVERCONTROL_SERVER_MAX_MAJOR_VERSION 2 + +namespace DevDriver +{ + namespace DriverControlProtocol + { + enum class SessionState + { + ReceivePayload = 0, + ProcessPayload, + SendPayload, + StepDriver + }; + + struct DriverControlSession + { + SessionState state; + DriverControlPayload payload; + }; + + DriverControlServer::DriverControlServer(IMsgChannel* pMsgChannel) + : BaseProtocolServer(pMsgChannel, Protocol::DriverControl, DRIVERCONTROL_SERVER_MIN_MAJOR_VERSION, DRIVERCONTROL_SERVER_MAX_MAJOR_VERSION) + , m_driverStatus(DriverStatus::EarlyInit) + , m_driverResumedEvent(true) + , m_numGpus(0) + , m_deviceClockCallbackInfo() + , m_numSessions(0) + , m_stepCounter(0) + { + DD_ASSERT(m_pMsgChannel != nullptr); + + for (uint32 gpuIndex = 0; gpuIndex < kMaxNumGpus; ++gpuIndex) + { + m_deviceClockModes[gpuIndex] = DeviceClockMode::Default; + } + } + + DriverControlServer::~DriverControlServer() + { + } + + void DriverControlServer::Finalize() + { + DD_STATIC_CONST uint32 kDefaultDriverStartTimeoutMs = 1000; + WaitForDriverStart(kDefaultDriverStartTimeoutMs); + + LockData(); + BaseProtocolServer::Finalize(); + UnlockData(); + } + + bool DriverControlServer::AcceptSession(const SharedPointer& pSession) + { + DD_UNUSED(pSession); + return true; + } + + void DriverControlServer::SessionEstablished(const SharedPointer& pSession) + { + DD_UNUSED(pSession); + + // Allocate session data for the newly established session + DriverControlSession* pSessionData = DD_NEW(DriverControlSession, m_pMsgChannel->GetAllocCb())(); + pSessionData->state = SessionState::ReceivePayload; + pSessionData->payload = {}; + Platform::AtomicIncrement(&m_numSessions); + pSession->SetUserData(pSessionData); + } + + void DriverControlServer::UpdateSession(const SharedPointer& pSession) + { + DriverControlSession* pSessionData = reinterpret_cast(pSession->GetUserData()); + + switch (pSessionData->state) + { + case SessionState::ReceivePayload: + { + uint32 bytesReceived = 0; + Result result = pSession->Receive(sizeof(pSessionData->payload), &pSessionData->payload, &bytesReceived, kNoWait); + + if (result == Result::Success) + { + DD_ASSERT(sizeof(pSessionData->payload) == bytesReceived); + pSessionData->state = SessionState::ProcessPayload; + } + + break; + } + + case SessionState::ProcessPayload: + { + switch (pSessionData->payload.command) + { + case DriverControlMessage::PauseDriverRequest: + { + Result result = Result::Error; + + // Only allow pausing if we're already in the running state. + if (m_driverStatus == DriverStatus::Running) + { + m_driverStatus = DriverStatus::Paused; + m_driverResumedEvent.Clear(); + result = Result::Success; + } + + pSessionData->payload.command = DriverControlMessage::PauseDriverResponse; + pSessionData->payload.pauseDriverResponse.result = result; + + pSessionData->state = SessionState::SendPayload; + + break; + } + + case DriverControlMessage::ResumeDriverRequest: + { + Result result = Result::Error; + + // Allow resuming the driver from the initial "halted on start" state and from the regular paused state. + if ((m_driverStatus == DriverStatus::HaltedOnStart) || (m_driverStatus == DriverStatus::Paused)) + { + // If we're resuming from the paused state, move to the running state, otherwise we're moving from + // halt on start to the late initialization phase. + m_driverStatus = (m_driverStatus == DriverStatus::Paused) ? DriverStatus::Running : DriverStatus::LateInit; + m_driverResumedEvent.Signal(); + result = Result::Success; + } + + pSessionData->payload.command = DriverControlMessage::ResumeDriverResponse; + pSessionData->payload.resumeDriverResponse.result = result; + + pSessionData->state = SessionState::SendPayload; + + break; + } + + case DriverControlMessage::QueryDeviceClockModeRequest: + { + Result result = Result::Error; + + LockData(); + + const uint32 gpuIndex = pSessionData->payload.queryDeviceClockModeRequest.gpuIndex; + if (gpuIndex < m_numGpus) + { + pSessionData->payload.queryDeviceClockModeResponse.mode = m_deviceClockModes[gpuIndex]; + result = Result::Success; + } + + UnlockData(); + + pSessionData->payload.command = DriverControlMessage::QueryDeviceClockModeResponse; + pSessionData->payload.queryDeviceClockModeResponse.result = result; + + pSessionData->state = SessionState::SendPayload; + + break; + } + + case DriverControlMessage::SetDeviceClockModeRequest: + { + Result result = Result::Error; + + LockData(); + + const uint32 gpuIndex = pSessionData->payload.setDeviceClockModeRequest.gpuIndex; + if (gpuIndex < m_numGpus) + { + if (m_deviceClockCallbackInfo.setCallback != nullptr) + { + const DeviceClockMode clockMode = pSessionData->payload.setDeviceClockModeRequest.mode; + + result = m_deviceClockCallbackInfo.setCallback(gpuIndex, + clockMode, + m_deviceClockCallbackInfo.pUserdata); + if (result == Result::Success) + { + // Update the current clock mode + m_deviceClockModes[gpuIndex] = clockMode; + } + } + } + + UnlockData(); + + pSessionData->payload.command = DriverControlMessage::SetDeviceClockModeResponse; + pSessionData->payload.setDeviceClockModeResponse.result = result; + + pSessionData->state = SessionState::SendPayload; + + break; + } + + case DriverControlMessage::QueryDeviceClockRequest: + { + Result result = Result::Error; + + float gpuClock = 0.0f; + float memClock = 0.0f; + + LockData(); + + const uint32 gpuIndex = pSessionData->payload.queryDeviceClockRequest.gpuIndex; + if (gpuIndex < m_numGpus) + { + if (m_deviceClockCallbackInfo.queryClockCallback != nullptr) + { + result = m_deviceClockCallbackInfo.queryClockCallback(gpuIndex, + &gpuClock, + &memClock, + m_deviceClockCallbackInfo.pUserdata); + } + } + + UnlockData(); + + pSessionData->payload.command = DriverControlMessage::QueryDeviceClockResponse; + pSessionData->payload.queryDeviceClockResponse.result = result; + pSessionData->payload.queryDeviceClockResponse.gpuClock = gpuClock; + pSessionData->payload.queryDeviceClockResponse.memClock = memClock; + + pSessionData->state = SessionState::SendPayload; + + break; + } + + case DriverControlMessage::QueryMaxDeviceClockRequest: + { + Result result = Result::Error; + + float maxGpuClock = 0.0f; + float maxMemClock = 0.0f; + + LockData(); + + const uint32 gpuIndex = pSessionData->payload.queryMaxDeviceClockRequest.gpuIndex; + if (gpuIndex < m_numGpus) + { + if (m_deviceClockCallbackInfo.queryMaxClockCallback != nullptr) + { + result = m_deviceClockCallbackInfo.queryMaxClockCallback(gpuIndex, + &maxGpuClock, + &maxMemClock, + m_deviceClockCallbackInfo.pUserdata); + } + } + + UnlockData(); + + pSessionData->payload.command = DriverControlMessage::QueryMaxDeviceClockResponse; + pSessionData->payload.queryMaxDeviceClockResponse.result = result; + pSessionData->payload.queryMaxDeviceClockResponse.maxGpuClock = maxGpuClock; + pSessionData->payload.queryMaxDeviceClockResponse.maxMemClock = maxMemClock; + + pSessionData->state = SessionState::SendPayload; + + break; + } + + case DriverControlMessage::QueryNumGpusRequest: + { + Result result = Result::Success; + + LockData(); + + const uint32 numGpus = m_numGpus; + + UnlockData(); + + pSessionData->payload.command = DriverControlMessage::QueryNumGpusResponse; + pSessionData->payload.queryNumGpusResponse.result = result; + pSessionData->payload.queryNumGpusResponse.numGpus = numGpus; + + pSessionData->state = SessionState::SendPayload; + + break; + } + + case DriverControlMessage::QueryDriverStatusRequest: + { + LockData(); + + const DriverStatus driverStatus = m_driverStatus; + + UnlockData(); + + pSessionData->payload.command = DriverControlMessage::QueryDriverStatusResponse; + + // On older versions, override EarlyInit and LateInit to the running state to maintain backwards compatibility. + if ((pSession->GetVersion() < DRIVERCONTROL_INITIALIZATION_STATUS_VERSION) && + ((driverStatus == DriverStatus::EarlyInit) || (driverStatus == DriverStatus::LateInit))) + { + pSessionData->payload.queryDriverStatusResponse.status = DriverStatus::Running; + } + else + { + pSessionData->payload.queryDriverStatusResponse.status = driverStatus; + } + + pSessionData->state = SessionState::SendPayload; + + break; + } + case DriverControlMessage::StepDriverRequest: + { + if (m_driverStatus == DriverStatus::Paused && m_stepCounter == 0) + { + int32 count = Platform::Max((int32) pSessionData->payload.stepDriverRequest.count, 1); + Platform::AtomicAdd(&m_stepCounter, count); + DD_PRINT(LogLevel::Verbose, "[DriverControlServer] Stepping driver %i frames", m_stepCounter); + pSessionData->state = SessionState::StepDriver; + ResumeDriver(); + } + else + { + pSessionData->payload.command = DriverControlMessage::StepDriverResponse; + pSessionData->payload.stepDriverResponse.result = Result::Error; + pSessionData->state = SessionState::SendPayload; + } + break; + } + default: + { + DD_UNREACHABLE(); + break; + } + } + + break; + } + + case SessionState::SendPayload: + { + Result result = pSession->Send(sizeof(pSessionData->payload), &pSessionData->payload, kNoWait); + if (result == Result::Success) + { + pSessionData->state = SessionState::ReceivePayload; + } + + break; + } + + case SessionState::StepDriver: + { + if (m_driverStatus == DriverStatus::Paused && m_stepCounter == 0) + { + pSessionData->payload.command = DriverControlMessage::StepDriverResponse; + pSessionData->payload.stepDriverResponse.result = Result::Success; + pSessionData->state = SessionState::SendPayload; + } + break; + } + + default: + { + DD_UNREACHABLE(); + break; + } + } + } + + void DriverControlServer::SessionTerminated(const SharedPointer& pSession, Result terminationReason) + { + DD_UNUSED(terminationReason); + DriverControlSession *pDriverControlSession = reinterpret_cast(pSession->SetUserData(nullptr)); + + // Free the session data + if (pDriverControlSession != nullptr) + { + Platform::AtomicDecrement(&m_numSessions); + DD_DELETE(pDriverControlSession, m_pMsgChannel->GetAllocCb()); + } + } + + void DriverControlServer::WaitForDriverResume() + { + if ((m_driverStatus == DriverStatus::Running) & (m_stepCounter > 0)) + { + long stepsRemaining = Platform::AtomicDecrement(&m_stepCounter); + DD_PRINT(LogLevel::Verbose, "[DriverControlServer] %i frames remaining", stepsRemaining); + if (stepsRemaining == 0) + { + PauseDriver(); + } + } + + if (m_driverStatus == DriverStatus::Paused) + { + Result waitResult = Result::NotReady; + while (waitResult == Result::NotReady) + { + if (m_numSessions == 0) + { + const ClientInfoStruct &clientInfo = m_pMsgChannel->GetClientInfo(); + ClientMetadata filter = {}; + + m_pMsgChannel->Send(kBroadcastClientId, + Protocol::System, + static_cast(SystemProtocol::SystemMessage::Halted), + filter, + sizeof(ClientInfoStruct), + &clientInfo); + DD_PRINT(LogLevel::Verbose, "[DriverControlServer] Sent system halted message"); + } + waitResult = m_driverResumedEvent.Wait(kBroadcastIntervalInMs); + } + DD_ASSERT(m_driverStatus == DriverStatus::Running); + } + } + + bool DriverControlServer::IsDriverInitialized() const + { + // The running and paused states can only be reached after the driver has fully initialized. + return ((m_driverStatus == DriverStatus::Running) || (m_driverStatus == DriverStatus::Paused)); + } + + void DriverControlServer::FinishDriverInitialization() + { + if (m_driverStatus == DriverStatus::LateInit) + { + DD_PRINT(LogLevel::Verbose, "[DriverControlServer] Driver initialization finished\n"); + m_driverStatus = DriverStatus::Running; + } + } + + DriverStatus DriverControlServer::QueryDriverStatus() + { + Platform::LockGuard lock(m_mutex); + + const DriverStatus driverStatus = m_driverStatus; + + return driverStatus; + } + + void DriverControlServer::PauseDriver() + { + if ((m_driverStatus == DriverStatus::Running) || (m_driverStatus == DriverStatus::EarlyInit)) + { + m_driverStatus = (m_driverStatus == DriverStatus::Running) ? DriverStatus::Paused : DriverStatus::HaltedOnStart; + DD_PRINT(LogLevel::Verbose, "[DriverControlServer] Paused driver\n"); + m_driverResumedEvent.Clear(); + } + } + + void DriverControlServer::ResumeDriver() + { + if ((m_driverStatus == DriverStatus::Paused) || (m_driverStatus == DriverStatus::HaltedOnStart)) + { + m_driverStatus = (m_driverStatus == DriverStatus::Paused) ? DriverStatus::Running : DriverStatus::LateInit; + DD_PRINT(LogLevel::Verbose, "[DriverControlServer] Resumed driver\n"); + m_driverResumedEvent.Signal(); + } + } + + void DriverControlServer::SetDeviceClockCallback(const DeviceClockCallbackInfo& deviceClockCallbackInfo) + { + LockData(); + + m_deviceClockCallbackInfo = deviceClockCallbackInfo; + + UnlockData(); + } + + void DriverControlServer::SetNumGpus(uint32 numGpus) + { + // Make sure the new number is less than or equal to the max. + DD_ASSERT(numGpus <= kMaxNumGpus); + + LockData(); + + m_numGpus = numGpus; + + UnlockData(); + } + + uint32 DriverControlServer::GetNumGpus() + { + LockData(); + + uint32 numGpus = m_numGpus; + + UnlockData(); + + return numGpus; + } + + DeviceClockMode DriverControlServer::GetDeviceClockMode(uint32 gpuIndex) + { + LockData(); + + DD_ASSERT(gpuIndex < m_numGpus); + + DeviceClockMode clockMode = m_deviceClockModes[gpuIndex]; + + UnlockData(); + + return clockMode; + } + + void DriverControlServer::LockData() + { + m_mutex.Lock(); + } + + void DriverControlServer::UnlockData() + { + m_mutex.Unlock(); + } + + void DriverControlServer::WaitForDriverStart(uint64 timeoutInMs) + { + ClientId clientId = kBroadcastClientId; + + if (m_driverStatus == DriverStatus::EarlyInit) + { + ClientMetadata filter = {}; + filter.status |= static_cast(ClientStatusFlags::HaltOnConnect); + if (m_pMsgChannel->FindFirstClient(filter, &clientId, kBroadcastIntervalInMs) == Result::Success) + { + DD_ASSERT(clientId != kBroadcastClientId); + DD_PRINT(LogLevel::Verbose, "[DriverControlServer] Found client requesting driver halt: %u", clientId); + PauseDriver(); + } + } + + if (m_driverStatus == DriverStatus::HaltedOnStart) + { + Result waitResult = Result::NotReady; + uint64 startTime = Platform::GetCurrentTimeInMs(); + uint64 currentTime = startTime; + + while (waitResult == Result::NotReady) + { + if (m_numSessions == 0) + { + if ((currentTime - startTime) > timeoutInMs) + { + ResumeDriver(); + break; + } + + const ClientInfoStruct &clientInfo = m_pMsgChannel->GetClientInfo(); + ClientMetadata filter = {}; + + m_pMsgChannel->Send(clientId, + Protocol::System, + static_cast(SystemProtocol::SystemMessage::Halted), + filter, + sizeof(ClientInfoStruct), + &clientInfo); + + DD_PRINT(LogLevel::Verbose, "[DriverControlServer] Sent system halted message"); + } + waitResult = m_driverResumedEvent.Wait(kBroadcastIntervalInMs); + currentTime = Platform::GetCurrentTimeInMs(); + } + } + else + { + // If we don't need to halt on start, just skip straight to the late init phase. + m_driverStatus = DriverStatus::LateInit; + } + } + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/etwClient.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/etwClient.cpp new file mode 100644 index 000000000..cc0ec74af --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/etwClient.cpp @@ -0,0 +1,166 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "protocols/etwClient.h" +#include "msgChannel.h" +#include + +namespace DevDriver +{ + namespace ETWProtocol + { + ETWClient::ETWClient(IMsgChannel* pMsgChannel) + : BaseProtocolClient(pMsgChannel, Protocol::ETW, kVersion, kVersion) + , m_sessionState(SessionState::Idle) + { + } + + ETWClient::~ETWClient() + { + } + + Result ETWClient::EnableTracing(ProcessId processId) + { + Result result = Result::Error; + + if (IsConnected() && m_sessionState == SessionState::Idle) + { + ETWPayload payload = {}; + payload.command = ETWMessage::BeginTrace; + payload.startTrace.processId = processId; + result = SendPayload(payload); + if (result == Result::Success) + { + // Receive chunk data until we reach a trace data sentinel. + result = ReceivePayload(payload); + if (result == Result::Success) + { + if (payload.command == ETWMessage::BeginResponse) + { + result = payload.startTraceResponse.result; + } + else + { + result = Result::Error; + } + } + } + } + + if (result == Result::Success) + { + m_sessionState = SessionState::Tracing; + } + return result; + } + + Result ETWClient::DisableTracing(size_t *pNumEvents) + { + Result result = Result::Error; + if (IsConnected() && m_sessionState == SessionState::Tracing) + { + ETWPayload payload = {}; + payload.command = ETWMessage::EndTrace; + payload.stopTrace.discard = (pNumEvents == nullptr); + result = SendPayload(payload); + if (result == Result::Success) + { + // Receive chunk data until we reach a trace data sentinel. + result = ReceivePayload(payload); + if (result == Result::Success) + { + if (payload.command == ETWMessage::EndResponse) + { + if (pNumEvents != nullptr) + { + *pNumEvents = payload.stopTraceResponse.numEventsCaptured; + } + + result = payload.stopTraceResponse.result; + if (result == Result::Success && payload.stopTraceResponse.numEventsCaptured != 0) + { + m_sessionState = SessionState::Waiting; + } + else + { + m_sessionState = SessionState::Idle; + } + } + else + { + result = Result::Error; + } + } + } + } + return result; + } + + Result ETWClient::GetTraceData(GpuEvent *buffer, size_t numEvents) + { + Result result = Result::Error; + if (IsConnected() && m_sessionState == SessionState::Waiting) + { + m_sessionState = SessionState::Receiving; + bool traceCompleted = false; + size_t numEventsCopied = 0; + ETWPayload payload = {}; + // Receive chunk data until we reach a trace data sentinel. + Result readResult = ReceivePayload(payload); + while (readResult == Result::Success && !traceCompleted) + { + switch (payload.command) + { + case ETWMessage::TraceDataChunk: + { + if ((numEventsCopied + payload.traceDataChunk.numEvents) <= numEvents && buffer != nullptr) + { + memcpy(&buffer[numEventsCopied], &payload.traceDataChunk.events[0], payload.traceDataChunk.numEvents * sizeof(GpuEvent)); + numEventsCopied += payload.traceDataChunk.numEvents; + } + break; + } + case ETWMessage::TraceDataSentinel: + { + if (numEventsCopied <= numEvents) + { + result = payload.traceDataSentinel.result; + } + traceCompleted = true; + break; + } + default: + result = Result::Error; + traceCompleted = true; + break; + } + if (!traceCompleted) + readResult = ReceivePayload(payload); + } + m_sessionState = SessionState::Idle; + } + return result; + } + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/etwServer.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/etwServer.cpp new file mode 100644 index 000000000..76e71c374 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/etwServer.cpp @@ -0,0 +1,83 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "protocols/etwServer.h" +#include "msgChannel.h" + +#include "util/queue.h" +#include "util/vector.h" +#include "../win/ddWinEtwServerSession.h" + +#include + +namespace DevDriver +{ + namespace ETWProtocol + { + ETWServer::ETWServer(IMsgChannel* pMsgChannel) + : BaseProtocolServer(pMsgChannel, Protocol::ETW, kVersion, kVersion) + { + DD_ASSERT(m_pMsgChannel != nullptr); + } + + ETWServer::~ETWServer() + { + } + + void ETWServer::Finalize() + { + } + + bool ETWServer::AcceptSession(const SharedPointer& pSession) + { + DD_UNUSED(pSession); + return true; + } + + void ETWServer::SessionEstablished(const SharedPointer& pSession) + { + // Allocate session data for the newly established session + ETWSession *newSession = DD_NEW(ETWSession, m_pMsgChannel->GetAllocCb())(pSession, m_pMsgChannel->GetAllocCb()); + pSession->SetUserData(newSession); + } + + void ETWServer::UpdateSession(const SharedPointer& pSession) + { + ETWSession* pSessionObject = reinterpret_cast(pSession->GetUserData()); + if (pSessionObject != nullptr) + pSessionObject->UpdateSession(); + } + + void ETWServer::SessionTerminated(const SharedPointer& pSession, Result terminationReason) + { + DD_UNUSED(terminationReason); + ETWSession* pSessionObject = reinterpret_cast(pSession->SetUserData(nullptr)); + + if (pSessionObject != nullptr) + { + DD_DELETE(pSessionObject, m_pMsgChannel->GetAllocCb()); + } + } + } // ETWProtocol +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/loggingClient.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/loggingClient.cpp new file mode 100644 index 000000000..c10ed3e07 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/loggingClient.cpp @@ -0,0 +1,314 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "protocols/loggingClient.h" +#include "msgChannel.h" + +#define LOGGING_CLIENT_MIN_MAJOR_VERSION 2 +#define LOGGING_CLIENT_MAX_MAJOR_VERSION 3 + +namespace DevDriver +{ + namespace LoggingProtocol + { + LoggingClient::LoggingClient(IMsgChannel* pMsgChannel) + : BaseProtocolClient(pMsgChannel, Protocol::Logging, LOGGING_CLIENT_MIN_MAJOR_VERSION, LOGGING_CLIENT_MAX_MAJOR_VERSION) + , m_loggingState(LoggingClientState::Idle) + , m_logMessages(pMsgChannel->GetAllocCb()) + , m_loggingFinishedEvent(true) + { + } + + LoggingClient::~LoggingClient() + { + } + + void LoggingClient::UpdateSession(const SharedPointer& pSession) + { + BaseProtocolClient::UpdateSession(pSession); + + if (IsLogging()) + { + // Receive all logging messages. + SizedPayloadContainer container = {}; + + Platform::LockGuard lock(m_mutex); + + // Attempt to receive messages until we either get all of them, or encounter an error. + while (IsLogging() && (ReceiveLoggingPayload(&container, kNoWait) == Result::Success)) + { + const LoggingHeader* pHeader = reinterpret_cast(container.payload); + if (pHeader->command == LoggingMessage::LogMessage) + { + DD_PRINT(LogLevel::Debug, "Received Logging Payload From Session %d!", pSession->GetSessionId()); + m_logMessages.PushBack(container); + } + else if (pHeader->command == LoggingMessage::LogMessageSentinel) + { + DD_PRINT(LogLevel::Debug, "Received Logging Sentinel From Session %d!", pSession->GetSessionId()); + + // Update our state since we've received all log messages. + m_loggingState = LoggingClientState::LoggingFinished; + + // Trigger the logging finished event once we get the sentinel. + // This allows the DisableLogging function to complete. + m_loggingFinishedEvent.Signal(); + + break; + } + else + { + // This should never happen. This means this is an unexpected packet type. + DD_UNREACHABLE(); + } + } + } + } + + void LoggingClient::SessionTerminated(const SharedPointer& pSession, Result terminationReason) + { + BaseProtocolClient::SessionTerminated(pSession, terminationReason); + // ResetState() dumps all pending log messages. If the server disconnects and the session dies, any + // unread log messages will be lost. + // @todo: Separate log messages from internal state and allow preservation past session termination. + ResetState(); + } + + Result LoggingClient::EnableLogging(LogLevel priority, LoggingCategory categoryMask) + { + Result result = Result::Error; + + if (IsConnected() && IsIdle()) + { + LoggingFilter filter = {}; + filter.priority = priority; + filter.category = categoryMask; + + SizedPayloadContainer container = {}; + container.CreatePayload(filter); + + result = TransactLoggingPayload(&container); + if (result == Result::Success) + { + const EnableLoggingResponsePayload& response = container.GetPayload(); + if (response.header.command == LoggingProtocol::LoggingMessage::EnableLoggingResponse) + { + result = response.result; + + if (result == Result::Success) + { + m_loggingState = LoggingClientState::Logging; + + // Reset the logging finished event since we're starting a new logging session. + m_loggingFinishedEvent.Clear(); + } + } + else + { + // Invalid response payload + result = Result::Error; + } + } + } + + return result; + } + + Result LoggingClient::DisableLogging() + { + Result result = Result::Error; + if (IsConnected() && IsLogging()) + { + SizedPayloadContainer container = {}; + LoggingHeader* pHeader = reinterpret_cast(container.payload); + pHeader->command = LoggingMessage::DisableLogging; + container.payloadSize = sizeof(LoggingHeader); + + if (SendLoggingPayload(container) == Result::Success) + { + // Wait until the session update thread receives the logging sentinel before we continue. + if (m_loggingFinishedEvent.Wait(kInfiniteTimeout) == Result::Success) + { + // If we've successfully finished logging, then set the result to success. + // (We may end up here in the Idle state if the session is disconnected during logging) + if (m_loggingState == LoggingClientState::LoggingFinished) + { + // Set the state back to idle. + m_loggingState = LoggingClientState::Idle; + + result = Result::Success; + } + else + { + // The ResetState function should always put us in the Idle state in the event of a session disconnect. + DD_ASSERT(m_loggingState == LoggingClientState::Idle); + } + } + else + { + // We should always successfully wait. + DD_UNREACHABLE(); + } + } + } + + return result; + } + + Result LoggingClient::QueryCategories(Vector& categories) + { + Result result = Result::Error; + + if (IsConnected() && IsIdle()) + { + SizedPayloadContainer container = {}; + LoggingHeader* pHeader = reinterpret_cast(container.payload); + pHeader->command = LoggingMessage::QueryCategoriesRequest; + container.payloadSize = sizeof(LoggingHeader); + + result = TransactLoggingPayload(&container); + if (result == Result::Success) + { + if (pHeader->command == LoggingMessage::QueryCategoriesNumResponse) + { + const QueryCategoriesNumResponsePayload* pNumResponse = + reinterpret_cast(container.payload); + const uint32 categoriesSent = pNumResponse->numCategories; + + // TODO: actually validate this instead of just asserting + DD_ASSERT(categoriesSent < kMaxCategoryCount); + + for (uint32 categoryIndex = 0; categoryIndex < categoriesSent; ++categoryIndex) + { + result = ReceiveLoggingPayload(&container); + if (result == Result::Success) + { + if (pHeader->command == LoggingMessage::QueryCategoriesDataResponse) + { + const QueryCategoriesDataResponsePayload* pDataResponse = + reinterpret_cast(container.payload); + categories.PushBack(pDataResponse->category); + } + else + { + // Invalid response payload + result = Result::Error; + break; + } + } + else + { + break; + } + } + } + else + { + // Invalid response payload + result = Result::Error; + } + } + } + + return result; + } + + Result LoggingClient::ReadLogMessages(Vector& logMessages) + { + Result result = (IsConnected() && IsLogging()) ? Result::NotReady : Result::Error; + Platform::LockGuard lock(m_mutex); + + while (m_logMessages.IsEmpty() == false) + { + const LogMessagePayload* pPayload = reinterpret_cast(m_logMessages.PeekFront()->payload); + logMessages.PushBack(Platform::Move(pPayload->message)); + m_logMessages.PopFront(); + } + if (logMessages.Size() > 0) + { + result = Result::Success; + } + + return result; + } + + bool LoggingClient::HasLogMessages() + { + Platform::LockGuard lock(m_mutex); + return (m_logMessages.IsEmpty() == false); + } + + void LoggingClient::ResetState() + { + Platform::LockGuard lock(m_mutex); + m_loggingState = LoggingClientState::Idle; + m_logMessages.Clear(); + m_loggingFinishedEvent.Signal(); + } + + bool LoggingClient::IsIdle() const + { + return (m_loggingState == LoggingClientState::Idle); + } + + bool LoggingClient::IsLogging() const + { + return (m_loggingState == LoggingClientState::Logging); + } + + Result LoggingClient::SendLoggingPayload( + const SizedPayloadContainer& container, + uint32 timeoutInMs, + uint32 retryInMs) + { + // Use the legacy size for the payload if we're connected to an older client, otherwise use the real size. + const Version sessionVersion = (m_pSession.IsNull() == false) ? m_pSession->GetVersion() : 0; + const uint32 payloadSize = (sessionVersion >= LOGGING_LARGE_MESSAGES_VERSION) ? container.payloadSize : kLegacyLoggingPayloadSize; + + return SendSizedPayload(container.payload, payloadSize, timeoutInMs, retryInMs); + } + + Result LoggingClient::ReceiveLoggingPayload( + SizedPayloadContainer* pContainer, + uint32 timeoutInMs, + uint32 retryInMs) + { + return ReceiveSizedPayload(pContainer->payload, sizeof(pContainer->payload), &pContainer->payloadSize, timeoutInMs, retryInMs); + } + + Result LoggingClient::TransactLoggingPayload( + SizedPayloadContainer* pContainer, + uint32 timeoutInMs, + uint32 retryInMs) + { + Result result = SendLoggingPayload(*pContainer, timeoutInMs, retryInMs); + if (result == Result::Success) + { + result = ReceiveLoggingPayload(pContainer, timeoutInMs, retryInMs); + } + + return result; + } + } +} diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/loggingServer.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/loggingServer.cpp new file mode 100644 index 000000000..a03c29f05 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/loggingServer.cpp @@ -0,0 +1,506 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "protocols/loggingServer.h" +#include "msgChannel.h" +#include +#include + +#define LOGGING_SERVER_MIN_MAJOR_VERSION 2 +#define LOGGING_SERVER_MAX_MAJOR_VERSION 3 + +namespace DevDriver +{ + namespace LoggingProtocol + { + static const NamedLoggingCategory kDefaultLoggingCategories[kReservedCategoryCount] = { + {kGeneralCategoryMask, "General"}, + {kSystemCategoryMask, "System"}, + }; + static_assert(kGeneralCategoryOffset == 0, "General category offset has changed unexpectedly"); + static_assert(kSystemCategoryOffset == 1, "System category offset has changed unexpectedly"); + + LoggingServer::LoggingServer(IMsgChannel* pMsgChannel) + : BaseProtocolServer(pMsgChannel, Protocol::Logging, LOGGING_SERVER_MIN_MAJOR_VERSION, LOGGING_SERVER_MAX_MAJOR_VERSION) + , m_categories() + , m_activeSessions(pMsgChannel->GetAllocCb()) + , m_numCategories(0) + { + DD_ASSERT(m_pMsgChannel != nullptr); + + // Initialize the category table + memset(&m_categories[0], 0, sizeof(m_categories)); + + // Initialize default logging categories + for (uint32 i = 0; i < kReservedCategoryCount; i++) + { + // Only initialize valid categorie entries + if (kDefaultLoggingCategories[i].category != 0 && kDefaultLoggingCategories[i].name[0] != 0) + { + // Validate that there hasn't been a mistake made somewhere + DD_ASSERT(kDefaultLoggingCategories[i].category == + ((LoggingCategory)1 << (kDefinableCategoryCount + i))); + + // Copy the category definition into our table and increment count + m_categories[kDefinableCategoryCount + i] = kDefaultLoggingCategories[i]; + m_numCategories++; + } + } + } + + LoggingServer::~LoggingServer() + { + } + + bool LoggingServer::AcceptSession(const SharedPointer& pSession) + { + DD_UNUSED(pSession); + return true; + } + + void LoggingServer::SessionEstablished(const SharedPointer& pSession) + { + DD_UNUSED(pSession); + // Allocate session data for the newly established session + LoggingSession *pSessionData = DD_NEW(LoggingSession, m_pMsgChannel->GetAllocCb())(m_pMsgChannel->GetAllocCb(), pSession); + pSessionData->state = SessionState::ReceivePayload; + pSessionData->loggingEnabled = false; + memset(&pSessionData->scratchPayload, 0, sizeof(pSessionData->scratchPayload)); + // Default to all messages enabled. + + pSessionData->filter.priority = LogLevel::Error; + pSessionData->filter.category = kAllLoggingCategories; + + LockData(); + + m_activeSessions.PushBack(pSessionData); + + UnlockData(); + + pSession->SetUserData(pSessionData); + } + + void LoggingServer::UpdateSession(const SharedPointer& pSession) + { + LoggingSession *pSessionData = reinterpret_cast(pSession->GetUserData()); + + switch (pSessionData->state) + { + case SessionState::ReceivePayload: + { + const Result result = pSession->ReceivePayload(&pSessionData->scratchPayload, kNoWait); + + if (result == Result::Success) + { + pSessionData->state = SessionState::ProcessPayload; + } + else if (result == Result::NotReady) + { + // If there's no messages to receive, we should send log messages if logging is enabled. + if (pSessionData->loggingEnabled) + { + LockData(); + + // Send as many log messages from our queue as possible. + + while (pSessionData->messages.PeekFront() != nullptr) + { + const SizedPayloadContainer* pPayload = pSessionData->messages.PeekFront(); + if (pSessionData->SendPayload(pPayload, kNoWait) == Result::Success) + { + DD_PRINT(LogLevel::Debug, "Sent Logging Payload To Session %d!", pSession->GetSessionId()); + // Pop the message off the queue since it was successfully sent. + pSessionData->messages.PopFront(); + } + else + { + break; + } + } + + UnlockData(); + } + } + + break; + } + + case SessionState::ProcessPayload: + { + SizedPayloadContainer& container = pSessionData->scratchPayload; + switch (container.GetPayload().command) + { + case LoggingMessage::QueryCategoriesRequest: + { + LockData(); + const uint32 numCategories = (m_numCategories <= kMaxCategoryCount) ? m_numCategories : 0; + UnlockData(); + + container.CreatePayload(numCategories); + pSessionData->state = SessionState::SendCategoriesNumResponse; + + break; + } + + case LoggingMessage::EnableLoggingRequest: + { + DD_PRINT(LogLevel::Debug, "Starting Logging!"); + LockData(); + pSessionData->filter = container.GetPayload().filter; + pSessionData->loggingEnabled = true; + UnlockData(); + + container.CreatePayload(Result::Success); + pSessionData->state = SessionState::SendPayload; + break; + } + + case LoggingMessage::DisableLogging: + { + DD_PRINT(LogLevel::Debug, "Stopping Logging!"); + LockData(); + + pSessionData->loggingEnabled = false; + pSessionData->state = SessionState::FinishLogging; + + // We have no additional messages to send so let the client know via the sentinel. + SizedPayloadContainer* pPayload = pSessionData->messages.AllocateBack(); + if (pPayload != nullptr) + { + pPayload->CreatePayload(LoggingMessage::LogMessageSentinel); + } + DD_PRINT(LogLevel::Debug, "Inserted logging sentinel"); + + UnlockData(); + + break; + } + + default: + { + DD_UNREACHABLE(); + break; + } + } + + break; + } + + case SessionState::FinishLogging: + { + DD_PRINT(LogLevel::Debug, "Finishing Logging!"); + LockData(); + + // Send as many log messages from our queue as possible. + if (pSessionData->messages.Size() > 0) + { + DD_PRINT(LogLevel::Debug, "Logging messages remaining: %u", pSessionData->messages.Size()); + const SizedPayloadContainer* pPayload = pSessionData->messages.PeekFront(); + while (pPayload != nullptr) + { + if (pSessionData->SendPayload(pPayload, kNoWait) == Result::Success) + { + // Pop the message off the queue since it was successfully sent. + pSessionData->messages.PopFront(); + + // Peek at the next message. + pPayload = pSessionData->messages.PeekFront(); + } + else + { + break; + } + } + } + else + { + pSessionData->state = SessionState::ReceivePayload; + } + + UnlockData(); + + break; + } + + case SessionState::SendPayload: + { + Result result = pSessionData->SendPayload(&pSessionData->scratchPayload, kNoWait); + if (result == Result::Success) + { + pSessionData->state = SessionState::ReceivePayload; + } + + break; + } + + case SessionState::SendCategoriesNumResponse: + { + Result result = pSessionData->SendPayload(&pSessionData->scratchPayload, kNoWait); + if (result == Result::Success) + { + const QueryCategoriesNumResponsePayload* pQueryCategoriesResponse = + reinterpret_cast(pSessionData->scratchPayload.payload); + if (pQueryCategoriesResponse->numCategories > 0) + { + pSessionData->itemIndex = 0; + pSessionData->numItems = 0; + pSessionData->state = SessionState::SendCategoriesDataResponse; + + // Prepare the payload for the first data response + if (pSessionData->numItems < m_numCategories) + { + // If m_numCategories were to get modified and pSessionData->itemIndex is already past + // the insertion point this can potentially cause an access violation by iterating past + // the array boundary. we prevent this by not allowing modification of this table while + // there are clients connected, but this probably needs to be addressed at some point. + while (m_categories[pSessionData->itemIndex].category == 0) + { + // Find first valid category + pSessionData->itemIndex++; + } + + const Version sessionVersion = pSession->GetVersion(); + LockData(); + const NamedLoggingCategory& category = m_categories[pSessionData->itemIndex]; + const size_t categoryNameSize = strlen(category.name) + 1; + QueryCategoriesDataResponsePayload::WritePayload(m_categories[pSessionData->itemIndex], + sessionVersion, + categoryNameSize, + &pSessionData->scratchPayload); + UnlockData(); + } + } + else + { + pSessionData->state = SessionState::ReceivePayload; + } + } + break; + } + + case SessionState::SendCategoriesDataResponse: + { + if (pSessionData->numItems < m_numCategories) + { + while (pSessionData->SendPayload(&pSessionData->scratchPayload, kNoWait) == Result::Success) + { + pSessionData->numItems++; + // Prepare the payload for the next data response if necessary + if (pSessionData->numItems < m_numCategories) + { + // Seek to the next valid category in the table. + // TODO: there is a potential issue here where if the number of categories increases + // but we've already passed the insertion point this will cause an access violation by + // iterating off the array. we prevent this by not allowing modification of this table while + // there are clients connected, but this probably needs to be addressed at some point. + while (m_categories[++pSessionData->itemIndex].category == 0) + { + } + + const Version sessionVersion = pSession->GetVersion(); + LockData(); + const NamedLoggingCategory& category = m_categories[pSessionData->itemIndex]; + const size_t categoryNameSize = strlen(category.name) + 1; + QueryCategoriesDataResponsePayload::WritePayload(m_categories[pSessionData->itemIndex], + sessionVersion, + categoryNameSize, + &pSessionData->scratchPayload); + UnlockData(); + } + else + { + // Break out of the send loop if we've finished sending all of the responses + break; + } + } + } + else + { + // We've sent all the responses. Return to normal operation. + pSessionData->state = SessionState::ReceivePayload; + } + + break; + } + + default: + { + DD_UNREACHABLE(); + break; + } + } + } + + void LoggingServer::SessionTerminated(const SharedPointer& pSession, Result terminationReason) + { + DD_UNUSED(terminationReason); + LoggingSession *pLoggingSession = reinterpret_cast(pSession->SetUserData(nullptr)); + + // Free the session data + if (pLoggingSession != nullptr) + { + LockData(); + + m_activeSessions.Remove(pLoggingSession); + + UnlockData(); + + DD_DELETE(pLoggingSession, m_pMsgChannel->GetAllocCb()); + } + } + + Result LoggingServer::AddCategoryTable(uint32 offset, uint32 count, const char **pCategoryTable) + { + Result result = Result::Error; + LockData(); + // Only allow modification if no sessions are connected. + // This is explicitly to prevent an issue where the number of categories changes while the server is + // trying to respond to QueryCategoriesRequest. + if (m_activeSessions.Size() == 0) + { + // Ensure that the offset is valid and that the count is nonzero + if ((offset < kDefinableCategoryCount) & (count > 0)) + { + bool available = true; + + // Ee need to make sure each index is valid and unused + for (uint32 index = 0; index < count; index++) + { + size_t catIndex = (index + offset); + + // If either of these cases are true we abort: + // 1) the index is greater than the maximum definable allowed + // 2) the category table defines a string and it is already taken + // note: this allows null pointers to be ignored in the category table + if ((catIndex >= kDefinableCategoryCount) || + ((pCategoryTable[index] != nullptr) & + (m_categories[catIndex].category != 0))) + { + available = false; + break; + } + } + + // If no errors were found + if (available) + { + for (uint32 index = 0; index < count; index++) + { + // Only do this if the entry in the category table is not null. Allows us to skip entries + // by defining null pointers inside the table + if (pCategoryTable[index] != nullptr) + { + const uint32 catIndex = index + offset; + const LoggingCategory mask = ((LoggingCategory)1 << catIndex) & kDefinableCategoryMask; + if (catIndex < kDefinableCategoryCount && mask != 0) + { + // Copy the category name into the local category table and calculate the bitmask + Platform::Strncpy(m_categories[catIndex].name, + pCategoryTable[index], + sizeof(NamedLoggingCategory::name)); + + m_categories[catIndex].category = mask; + m_numCategories++; + } + else + { + DD_UNREACHABLE(); + } + } + } + result = Result::Success; + } + } + } + UnlockData(); + return result; + } + + void LoggingServer::Log(LogLevel priority, LoggingCategory category, const char* pFormat, va_list args) + { + // todo: figure out a way to make this threadsafe. right now Log() will cause serialization + // of separate threads + LockData(); + + // We only need to do work if there are active sessions to send messages to. + if (m_activeSessions.Size() > 0) + { + // define the filter out here so we just copy it into destination messages + LogMessage message = {}; + message.filter.priority = priority; + message.filter.category = category; + Platform::Vsnprintf(message.message, + sizeof(LogMessage::message), + pFormat, + args); + // Calculate the message size (including the null terminator). + const size_t messageSize = strlen(message.message) + 1; + + for (auto& pSessionData : m_activeSessions) + { + const LoggingFilter& currentFilter = pSessionData->filter; + const bool sendMessage = (currentFilter.priority <= priority) & + ((currentFilter.category & category) != 0); + + // if the session has logging enabled and the message satisfies the filter of the session + if ((pSessionData->loggingEnabled) & sendMessage) + { + const Version sessionVersion = pSessionData->pSession->GetVersion(); + + // Allocate a message and copy the message into the buffer of all sessions + SizedPayloadContainer* pPayloadContainer = pSessionData->messages.AllocateBack(); + if (pPayloadContainer != nullptr) + { + LogMessagePayload::WritePayload(message, + sessionVersion, + messageSize, + pPayloadContainer); + } + } + } + } + + UnlockData(); + } + + void LoggingServer::LockData() + { + m_mutex.Lock(); + } + + void LoggingServer::UnlockData() + { + m_mutex.Unlock(); + } + + Result LoggingSession::SendPayload(const SizedPayloadContainer* pPayload, uint32 timeoutInMs) + { + // If we're running an older logging version, always write the fixed payload size. Otherwise, write the real size. + const uint32 payloadSize = + (pSession->GetVersion() >= LOGGING_LARGE_MESSAGES_VERSION) ? pPayload->payloadSize : kLegacyLoggingPayloadSize; + + return pSession->Send(payloadSize, pPayload->payload, timeoutInMs); + } + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/rgpClient.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/rgpClient.cpp new file mode 100644 index 000000000..33ce74be0 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/rgpClient.cpp @@ -0,0 +1,363 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "protocols/rgpClient.h" +#include "msgChannel.h" + +#include + +#define RGP_CLIENT_MIN_MAJOR_VERSION 2 +#define RGP_CLIENT_MAX_MAJOR_VERSION 6 + +namespace DevDriver +{ + namespace RGPProtocol + { + RGPClient::RGPClient(IMsgChannel* pMsgChannel) + : BaseProtocolClient(pMsgChannel, Protocol::RGP, RGP_CLIENT_MIN_MAJOR_VERSION, RGP_CLIENT_MAX_MAJOR_VERSION) + { + memset(&m_traceContext, 0, sizeof(m_traceContext)); + } + + RGPClient::~RGPClient() + { + } + + Result RGPClient::BeginTrace(const BeginTraceInfo& traceInfo) + { + Result result = Result::Error; + + if ((m_traceContext.state == TraceState::Idle) && + (traceInfo.callbackInfo.chunkCallback != nullptr)) + { + RGPPayload payload = {}; + payload.command = RGPMessage::ExecuteTraceRequest; + + if (GetSessionVersion() < RGP_PROFILING_CLOCK_MODES_VERSION) + { + payload.executeTraceRequest.parameters.gpuMemoryLimitInMb = traceInfo.parameters.gpuMemoryLimitInMb; + payload.executeTraceRequest.parameters.numPreparationFrames = traceInfo.parameters.numPreparationFrames; + payload.executeTraceRequest.parameters.flags.u32All = traceInfo.parameters.flags.u32All; + } + else if ((GetSessionVersion() == RGP_PROFILING_CLOCK_MODES_VERSION) || + (GetSessionVersion() == RGP_TRACE_PROGRESS_VERSION)) + { + payload.executeTraceRequestV2.parameters.gpuMemoryLimitInMb = traceInfo.parameters.gpuMemoryLimitInMb; + payload.executeTraceRequestV2.parameters.numPreparationFrames = traceInfo.parameters.numPreparationFrames; + payload.executeTraceRequestV2.parameters.clockMode = ProfilingClockMode::Stable; + payload.executeTraceRequestV2.parameters.flags.u32All = traceInfo.parameters.flags.u32All; + } + else if (GetSessionVersion() == RGP_COMPUTE_PRESENTS_VERSION) + { + payload.executeTraceRequestV3.parameters.gpuMemoryLimitInMb = traceInfo.parameters.gpuMemoryLimitInMb; + payload.executeTraceRequestV3.parameters.numPreparationFrames = traceInfo.parameters.numPreparationFrames; + payload.executeTraceRequestV3.parameters.flags.u32All = traceInfo.parameters.flags.u32All; + } + else if (GetSessionVersion() == RGP_TRIGGER_MARKERS_VERSION) + { + payload.executeTraceRequestV4.parameters.gpuMemoryLimitInMb = traceInfo.parameters.gpuMemoryLimitInMb; + payload.executeTraceRequestV4.parameters.numPreparationFrames = traceInfo.parameters.numPreparationFrames; + payload.executeTraceRequestV4.parameters.flags.u32All = traceInfo.parameters.flags.u32All; + + payload.executeTraceRequestV4.parameters.beginTagLow = + static_cast(traceInfo.parameters.beginTag & 0xFFFFFFFF); + payload.executeTraceRequestV4.parameters.beginTagHigh = + static_cast((traceInfo.parameters.beginTag >> 32) & 0xFFFFFFFF); + + payload.executeTraceRequestV4.parameters.endTagLow = + static_cast(traceInfo.parameters.endTag & 0xFFFFFFFF); + payload.executeTraceRequestV4.parameters.endTagHigh = + static_cast((traceInfo.parameters.endTag >> 32) & 0xFFFFFFFF); + + Platform::Strncpy(payload.executeTraceRequestV4.parameters.beginMarker, + traceInfo.parameters.beginMarker, + sizeof(payload.executeTraceRequestV4.parameters.beginMarker)); + + Platform::Strncpy(payload.executeTraceRequestV4.parameters.endMarker, + traceInfo.parameters.endMarker, + sizeof(payload.executeTraceRequestV4.parameters.endMarker)); + } + else + { + // Unhandled protocol version + DD_UNREACHABLE(); + } + + result = SendPayload(payload); + + if (result == Result::Success) + { + m_traceContext.traceInfo = traceInfo; + m_traceContext.state = TraceState::TraceRequested; + } + else + { + // If we fail to send the payload, fail the trace. + m_traceContext.state = TraceState::Error; + result = Result::Error; + } + } + + return result; + } + + Result RGPClient::EndTrace(uint32* pNumChunks, uint64* pTraceSizeInBytes) + { + Result result = Result::Error; + + if ((m_traceContext.state == TraceState::TraceRequested) && + (pNumChunks != nullptr) && + (pTraceSizeInBytes != nullptr)) + { + if (GetSessionVersion() >= RGP_TRACE_PROGRESS_VERSION) + { + RGPPayload payload = {}; + + const uint32 headerTimeout = kRGPChunkTimeoutInMs * (m_traceContext.traceInfo.parameters.numPreparationFrames + 1); + + // Attempt to receive the trace data header. + result = ReceivePayload(payload, headerTimeout); + if ((result == Result::Success) && (payload.command == RGPMessage::TraceDataHeader)) + { + // We've successfully received the trace data header. Check if the trace was successful. + result = payload.traceDataHeader.result; + if (result == Result::Success) + { + m_traceContext.state = TraceState::TraceCompleted; + m_traceContext.numChunks = payload.traceDataHeader.numChunks; + m_traceContext.numChunksReceived = 0; + + *pNumChunks = payload.traceDataHeader.numChunks; + *pTraceSizeInBytes = payload.traceDataHeader.sizeInBytes; + } + else + { + // Reset the trace state. + m_traceContext.state = TraceState::Error; + + // Don't overwrite the result from the trace header here. We want to return that to the caller. + } + } + else + { + m_traceContext.state = TraceState::Error; + result = Result::Error; + } + } + else + { + m_traceContext.state = TraceState::TraceCompleted; + result = Result::Unavailable; + } + } + + return result; + } + + Result RGPClient::ReadTraceDataChunk() + { + Result result = Result::Error; + + RGPPayload payload = {}; + + if (m_traceContext.state == TraceState::TraceCompleted) + { + if (GetSessionVersion() >= RGP_TRACE_PROGRESS_VERSION) + { + result = ReceivePayload(payload, kRGPChunkTimeoutInMs); + + if (result == Result::Success) + { + if ((payload.command == RGPMessage::TraceDataChunk) && (m_traceContext.numChunksReceived < m_traceContext.numChunks)) + { + // Call the chunk callback with the trace data. + m_traceContext.traceInfo.callbackInfo.chunkCallback(&payload.traceDataChunk.chunk, m_traceContext.traceInfo.callbackInfo.pUserdata); + + ++m_traceContext.numChunksReceived; + + // If we have no chunks left, the trace process was successfully completed. + if (m_traceContext.numChunksReceived == m_traceContext.numChunks) + { + // Make sure we read the sentinel value before returning. It should always mark the end of the trace data chunk stream. + result = ReceivePayload(payload, kRGPChunkTimeoutInMs); + + if ((result == Result::Success) && (payload.command == RGPMessage::TraceDataSentinel)) + { + result = Result::EndOfStream; + m_traceContext.state = TraceState::Idle; + } + else + { + // Failed to receive a trace data chunk. Fail the trace. + m_traceContext.state = TraceState::Error; + result = Result::Error; + } + } + } + else + { + // Failed to receive a trace data chunk. Fail the trace. + m_traceContext.state = TraceState::Error; + result = Result::Error; + } + } + else + { + // Failed to receive a trace data chunk. Fail the trace. + m_traceContext.state = TraceState::Error; + result = Result::Error; + } + } + else if (GetSessionVersion() < RGP_TRACE_PROGRESS_VERSION) + { + const uint32 firstChunkTimeout = kRGPChunkTimeoutInMs * (m_traceContext.traceInfo.parameters.numPreparationFrames + 1); + const uint32 packetTimeout = (m_traceContext.numChunksReceived == 0) ? firstChunkTimeout : kRGPChunkTimeoutInMs; + + result = ReceivePayload(payload, packetTimeout); + + if (result == Result::Success) + { + if (payload.command == RGPMessage::TraceDataChunk) + { + // Call the chunk callback with the trace data. + m_traceContext.traceInfo.callbackInfo.chunkCallback(&payload.traceDataChunk.chunk, m_traceContext.traceInfo.callbackInfo.pUserdata); + + ++m_traceContext.numChunksReceived; + } + else if (payload.command == RGPMessage::TraceDataSentinel) + { + result = Result::EndOfStream; + } + } + else + { + // Failed to receive a trace data chunk. Fail the trace. + m_traceContext.state = TraceState::Error; + result = Result::Error; + } + } + } + + return result; + } + + Result RGPClient::AbortTrace() + { + Result result = Result::Error; + + RGPPayload payload = {}; + + if (m_traceContext.state == TraceState::TraceCompleted) + { + if (GetSessionVersion() >= RGP_TRACE_PROGRESS_VERSION) + { + payload.command = RGPMessage::AbortTrace; + + result = SendPayload(payload); + + if (result == Result::Success) + { + // Discard all messages until we find the trace data sentinel. + while ((result == Result::Success) && (payload.command != RGPMessage::TraceDataSentinel)) + { + result = ReceivePayload(payload); + } + + if ((result == Result::Success) && + (payload.command == RGPMessage::TraceDataSentinel) && + (payload.traceDataSentinel.result == Result::Aborted)) + { + // We've successfully aborted the trace. + m_traceContext.state = TraceState::Idle; + } + else + { + // Fail the trace if this process does not succeed. + m_traceContext.state = TraceState::Error; + result = Result::Error; + } + } + else + { + // If we fail to send the payload, fail the trace. + m_traceContext.state = TraceState::Error; + result = Result::Error; + } + } + else + { + // Support for aborting traces is not available until the trace progress version. + result = Result::Unavailable; + } + } + + return result; + } + + Result RGPClient::QueryProfilingStatus(ProfilingStatus* pStatus) + { + Result result = Result::Error; + + if ((pStatus != nullptr) && IsConnected()) + { + RGPPayload payload = {}; + payload.command = RGPMessage::QueryProfilingStatusRequest; + + if ((Transact(payload, payload) == Result::Success) && + (payload.command == RGPMessage::QueryProfilingStatusResponse)) + { + *pStatus = payload.queryProfilingStatusResponse.status; + result = Result::Success; + } + } + + return result; + } + + Result RGPClient::EnableProfiling() + { + Result result = Result::Error; + + if (IsConnected()) + { + RGPPayload payload = {}; + payload.command = RGPMessage::EnableProfilingRequest; + + if ((Transact(payload, payload) == Result::Success) && + (payload.command == RGPMessage::EnableProfilingResponse)) + { + result = payload.enableProfilingStatusResponse.result; + } + } + + return result; + } + + void RGPClient::ResetState() + { + memset(&m_traceContext, 0, sizeof(m_traceContext)); + } + } + +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/rgpServer.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/rgpServer.cpp new file mode 100644 index 000000000..f2e8123e7 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/rgpServer.cpp @@ -0,0 +1,669 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "protocols/rgpServer.h" +#include "msgChannel.h" +#include + +#include "util/queue.h" + +#define RGP_SERVER_MIN_MAJOR_VERSION 2 +#define RGP_SERVER_MAX_MAJOR_VERSION 6 + +namespace DevDriver +{ + namespace RGPProtocol + { + enum class SessionState + { + ReceivePayload = 0, + ProcessPayload, + SendPayload, + TransferTraceData + }; + + struct RGPSession + { + SessionState state; + Version version; + uint64 traceSizeInBytes; + Queue chunkPayloads; + RGPPayload payload; + bool abortRequestedByClient; + + explicit RGPSession(const AllocCb& allocCb) + : state(SessionState::ReceivePayload) + , version(0) + , traceSizeInBytes(0) + , chunkPayloads(allocCb) + , payload() + , abortRequestedByClient(false) + { + } + }; + + RGPServer::RGPServer(IMsgChannel* pMsgChannel) + : BaseProtocolServer(pMsgChannel, Protocol::RGP, RGP_SERVER_MIN_MAJOR_VERSION, RGP_SERVER_MAX_MAJOR_VERSION) + , m_traceStatus(TraceStatus::Idle) + , m_pCurrentSessionData(nullptr) + , m_profilingStatus(ProfilingStatus::NotAvailable) + { + DD_ASSERT(m_pMsgChannel != nullptr); + memset(&m_traceParameters, 0, sizeof(m_traceParameters)); + } + + RGPServer::~RGPServer() + { + } + + void RGPServer::Finalize() + { + Platform::LockGuard lock(m_mutex); + BaseProtocolServer::Finalize(); + } + + bool RGPServer::AcceptSession(const SharedPointer& pSession) + { + DD_UNUSED(pSession); + return true; + } + + void RGPServer::SessionEstablished(const SharedPointer& pSession) + { + DD_UNUSED(pSession); + + // Allocate session data for the newly established session + RGPSession* pSessionData = DD_NEW(RGPSession, m_pMsgChannel->GetAllocCb())(m_pMsgChannel->GetAllocCb()); + pSessionData->state = SessionState::ReceivePayload; + memset(&pSessionData->payload, 0, sizeof(RGPPayload)); + + pSession->SetUserData(pSessionData); + } + + void RGPServer::UpdateSession(const SharedPointer& pSession) + { + RGPSession* pSessionData = reinterpret_cast(pSession->GetUserData()); + + Platform::LockGuard lock(m_mutex); + + switch (m_traceStatus) + { + case TraceStatus::Idle: + { + // Process messages in when we're not executing a trace. + switch (pSessionData->state) + { + case SessionState::ReceivePayload: + { + uint32 bytesReceived = 0; + Result result = pSession->Receive(sizeof(pSessionData->payload), &pSessionData->payload, &bytesReceived, kNoWait); + + if (result == Result::Success) + { + DD_ASSERT(sizeof(pSessionData->payload) == bytesReceived); + pSessionData->state = SessionState::ProcessPayload; + } + + break; + } + + case SessionState::ProcessPayload: + { + switch (pSessionData->payload.command) + { + case RGPMessage::ExecuteTraceRequest: + { + // We should always have a null session data pointer when in the idle trace state. + DD_ASSERT(m_pCurrentSessionData == nullptr); + + if (m_profilingStatus == ProfilingStatus::Enabled) + { + if (pSession->GetVersion() < RGP_PROFILING_CLOCK_MODES_VERSION) + { + const TraceParameters& traceParameters = pSessionData->payload.executeTraceRequest.parameters; + m_traceParameters.gpuMemoryLimitInMb = traceParameters.gpuMemoryLimitInMb; + m_traceParameters.numPreparationFrames = traceParameters.numPreparationFrames; + m_traceParameters.flags.u32All = traceParameters.flags.u32All; + } + else if ((pSession->GetVersion() == RGP_PROFILING_CLOCK_MODES_VERSION) || + (pSession->GetVersion() == RGP_TRACE_PROGRESS_VERSION)) + { + const TraceParametersV2& traceParameters = pSessionData->payload.executeTraceRequestV2.parameters; + m_traceParameters.gpuMemoryLimitInMb = traceParameters.gpuMemoryLimitInMb; + m_traceParameters.numPreparationFrames = traceParameters.numPreparationFrames; + m_traceParameters.flags.u32All = traceParameters.flags.u32All; + } + else if (pSession->GetVersion() == RGP_COMPUTE_PRESENTS_VERSION) + { + const TraceParametersV3& traceParameters = pSessionData->payload.executeTraceRequestV3.parameters; + m_traceParameters.gpuMemoryLimitInMb = traceParameters.gpuMemoryLimitInMb; + m_traceParameters.numPreparationFrames = traceParameters.numPreparationFrames; + m_traceParameters.flags.u32All = traceParameters.flags.u32All; + } + else if (pSession->GetVersion() == RGP_TRIGGER_MARKERS_VERSION) + { + const TraceParametersV4& traceParameters = pSessionData->payload.executeTraceRequestV4.parameters; + m_traceParameters.gpuMemoryLimitInMb = traceParameters.gpuMemoryLimitInMb; + m_traceParameters.numPreparationFrames = traceParameters.numPreparationFrames; + m_traceParameters.flags.u32All = traceParameters.flags.u32All; + + m_traceParameters.beginTag = + ((static_cast(traceParameters.beginTagHigh) << 32) | traceParameters.beginTagLow); + m_traceParameters.endTag = + ((static_cast(traceParameters.endTagHigh) << 32) | traceParameters.endTagLow); + + Platform::Strncpy(m_traceParameters.beginMarker, + traceParameters.beginMarker, + sizeof(m_traceParameters.beginMarker)); + + Platform::Strncpy(m_traceParameters.endMarker, + traceParameters.endMarker, + sizeof(m_traceParameters.endMarker)); + } + else + { + // Unhandled protocol version + DD_UNREACHABLE(); + } + + m_traceStatus = TraceStatus::Pending; + m_pCurrentSessionData = pSessionData; + m_pCurrentSessionData->state = SessionState::TransferTraceData; + m_pCurrentSessionData->version = pSession->GetVersion(); + m_pCurrentSessionData->traceSizeInBytes = 0; + } + else + { + if (pSessionData->version >= RGP_TRACE_PROGRESS_VERSION) + { + pSessionData->payload.command = RGPMessage::TraceDataHeader; + pSessionData->payload.traceDataHeader.numChunks = 0; + pSessionData->payload.traceDataHeader.sizeInBytes = 0; + pSessionData->payload.traceDataHeader.result = Result::Error; + } + else + { + pSessionData->payload.command = RGPMessage::TraceDataSentinel; + pSessionData->payload.traceDataSentinel.result = Result::Error; + } + + pSessionData->state = SessionState::SendPayload; + } + + break; + } + + case RGPMessage::QueryProfilingStatusRequest: + { + pSessionData->payload.command = RGPMessage::QueryProfilingStatusResponse; + + const ProfilingStatus profilingStatus = m_profilingStatus; + + pSessionData->payload.queryProfilingStatusResponse.status = profilingStatus; + + pSessionData->state = SessionState::SendPayload; + + break; + } + + case RGPMessage::EnableProfilingRequest: + { + pSessionData->payload.command = RGPMessage::EnableProfilingResponse; + + Result result = Result::Error; + + // Profiling can only be enabled before the server is finalized + if ((m_isFinalized == false) & (m_profilingStatus == ProfilingStatus::Available)) + { + m_profilingStatus = ProfilingStatus::Enabled; + result = Result::Success; + } + + pSessionData->payload.enableProfilingStatusResponse.result = result; + + pSessionData->state = SessionState::SendPayload; + + break; + } + default: + { + // Invalid command + DD_UNREACHABLE(); + break; + } + } + + break; + } + + case SessionState::SendPayload: + { + Result result = pSession->Send(sizeof(pSessionData->payload), &pSessionData->payload, kNoWait); + if (result == Result::Success) + { + pSessionData->state = SessionState::ReceivePayload; + } + + break; + } + + default: + { + DD_UNREACHABLE(); + break; + } + } + + break; + } + + case TraceStatus::Running: + case TraceStatus::Finishing: + { + // We should never enter this state with a null session data pointer. + // The termination callback should prevent this from happening. + DD_ASSERT(m_pCurrentSessionData != nullptr); + + // Make sure we only attempt to talk to the session that requested the trace. + if (m_pCurrentSessionData == pSessionData) + { + // The session should always be ready to transfer data in this state. + DD_ASSERT(m_pCurrentSessionData->state == SessionState::TransferTraceData); + + // Look for an abort request if necessary. + if ((pSession->GetVersion() >= RGP_TRACE_PROGRESS_VERSION) && (!pSessionData->abortRequestedByClient)) + { + uint32 bytesReceived = 0; + Result result = pSession->Receive(sizeof(pSessionData->payload), &pSessionData->payload, &bytesReceived, kNoWait); + + if (result == Result::Success) + { + DD_ASSERT(sizeof(pSessionData->payload) == bytesReceived); + + if (pSessionData->payload.command == RGPMessage::AbortTrace) + { + pSessionData->abortRequestedByClient = true; + } + else + { + // We should only ever receive abort requests in this state. + DD_ALERT_ALWAYS(); + } + } + } + + // If the client requested an abort, then send the trace sentinel. + if (pSessionData->abortRequestedByClient) + { + m_pCurrentSessionData->payload.command = RGPMessage::TraceDataSentinel; + m_pCurrentSessionData->payload.traceDataSentinel.result = Result::Aborted; + + Result result = pSession->Send(sizeof(pSessionData->payload), &pSessionData->payload, kNoWait); + if (result == Result::Success) + { + // The trace was aborted. Move back to idle and reset all state. + ClearCurrentSession(); + } + } + else + { + // When trace progress is supported, we only send data if we're in the finishing state. + const bool sendTraceData = (pSession->GetVersion() >= RGP_TRACE_PROGRESS_VERSION) ? (m_traceStatus == TraceStatus::Finishing) + : true; + if (sendTraceData) + { + Result result = Result::Success; + + while (m_pCurrentSessionData->chunkPayloads.IsEmpty() == false) + { + result = pSession->Send(sizeof(RGPPayload), m_pCurrentSessionData->chunkPayloads.PeekFront(), kNoWait); + + if (result == Result::Success) + { + m_pCurrentSessionData->chunkPayloads.PopFront(); + } + else + { + break; + } + } + + if ((result == Result::Success) & + (m_traceStatus == TraceStatus::Finishing)) + { + // If we make it this far with a success result in the Finishing state, we've sent all the chunk data. + ClearCurrentSession(); + } + } + } + } + + break; + } + + case TraceStatus::Aborting: + { + if (m_pCurrentSessionData->version >= RGP_TRACE_PROGRESS_VERSION) + { + m_pCurrentSessionData->payload.command = RGPMessage::TraceDataHeader; + m_pCurrentSessionData->payload.traceDataHeader.numChunks = 0; + m_pCurrentSessionData->payload.traceDataHeader.sizeInBytes = 0; + m_pCurrentSessionData->payload.traceDataHeader.result = Result::Error; + } + else + { + m_pCurrentSessionData->payload.command = RGPMessage::TraceDataSentinel; + m_pCurrentSessionData->payload.traceDataSentinel.result = Result::Error; + } + + Result result = pSession->Send(sizeof(pSessionData->payload), &pSessionData->payload, kNoWait); + if (result == Result::Success) + { + // The trace aborted. Move back to idle and reset all state. + ClearCurrentSession(); + } + + break; + } + + default: + { + // Do nothing + break; + } + } + } + + void RGPServer::SessionTerminated(const SharedPointer& pSession, Result terminationReason) + { + DD_UNUSED(terminationReason); + RGPSession *pRGPSession = reinterpret_cast(pSession->SetUserData(nullptr)); + + // Free the session data + if (pRGPSession != nullptr) + { + Platform::LockGuard lock(m_mutex); + + if (m_pCurrentSessionData == pRGPSession) + { + m_traceStatus = TraceStatus::Idle; + + m_pCurrentSessionData = nullptr; + } + DD_DELETE(pRGPSession, m_pMsgChannel->GetAllocCb()); + } + } + + bool RGPServer::TracesEnabled() + { + Platform::LockGuard lock(m_mutex); + + const bool tracesEnabled = (m_profilingStatus == ProfilingStatus::Enabled); + + return tracesEnabled; + } + + Result RGPServer::EnableTraces() + { + Result result = Result::Error; + + Platform::LockGuard lock(m_mutex); + + // Make sure we're not currently running a trace and that traces are currently disabled. + if ((m_traceStatus == TraceStatus::Idle) & (m_profilingStatus == ProfilingStatus::NotAvailable)) + { + m_profilingStatus = ProfilingStatus::Available; + result = Result::Success; + } + + return result; + } + + Result RGPServer::DisableTraces() + { + Result result = Result::Error; + + Platform::LockGuard lock(m_mutex); + + // Make sure we're not currently running a trace. + if (m_traceStatus == TraceStatus::Idle) + { + m_profilingStatus = ProfilingStatus::NotAvailable; + result = Result::Success; + } + + return result; + } + + bool RGPServer::IsTracePending() + { + // Platform::LockGuard lock(m_mutex); + + const bool isTracePending = (m_traceStatus == TraceStatus::Pending); + + return isTracePending; + } + + bool RGPServer::IsTraceRunning() + { + Platform::LockGuard lock(m_mutex); + + const bool isTraceRunning = (m_traceStatus == TraceStatus::Running); + + return isTraceRunning; + } + + Result RGPServer::BeginTrace() + { + Result result = Result::Error; + + Platform::LockGuard lock(m_mutex); + + // A trace can only begin if a client requests one. + if (m_traceStatus == TraceStatus::Pending) + { + m_traceStatus = TraceStatus::Running; + result = Result::Success; + } + + return result; + } + + Result RGPServer::EndTrace() + { + Result result = Result::Error; + + Platform::LockGuard lock(m_mutex); + + // Make sure there was a trace running before. + if (m_traceStatus == TraceStatus::Running) + { + if (m_pCurrentSessionData != nullptr) + { + if (m_pCurrentSessionData->version >= RGP_TRACE_PROGRESS_VERSION) + { + // Inject the trace header + RGPPayload *pPayload = m_pCurrentSessionData->chunkPayloads.AllocateFront(); + result = (pPayload != nullptr) ? Result::Success : Result::Error; + + if (result == Result::Success) + { + // todo: Support trace sizes larger than 4GB + DD_ASSERT(m_pCurrentSessionData->traceSizeInBytes < (~0u)); + + pPayload->command = RGPMessage::TraceDataHeader; + pPayload->traceDataHeader.result = Result::Success; + pPayload->traceDataHeader.numChunks = static_cast(m_pCurrentSessionData->chunkPayloads.Size() - 1); + pPayload->traceDataHeader.sizeInBytes = static_cast(m_pCurrentSessionData->traceSizeInBytes); + + pPayload = m_pCurrentSessionData->chunkPayloads.AllocateBack(); + result = (pPayload != nullptr) ? Result::Success : Result::Error; + } + + if (result == Result::Success) + { + pPayload->command = RGPMessage::TraceDataSentinel; + pPayload->traceDataSentinel.result = Result::Success; + + m_traceStatus = TraceStatus::Finishing; + } + } + else + { + RGPPayload *pPayload = m_pCurrentSessionData->chunkPayloads.AllocateBack(); + if (pPayload != nullptr) + { + m_traceStatus = TraceStatus::Finishing; + pPayload->command = RGPMessage::TraceDataSentinel; + pPayload->traceDataSentinel.result = Result::Success; + result = Result::Success; + } + } + } + else + { + // The client that requested the trace has disconnected. Discard the trace. + m_traceStatus = TraceStatus::Idle; + result = Result::Success; + } + + } + + DD_ASSERT(result == Result::Success); + return result; + } + + Result RGPServer::AbortTrace() + { + Result result = Result::Error; + + Platform::LockGuard lock(m_mutex); + + // Make sure there was a trace running before. + if (m_traceStatus == TraceStatus::Running) + { + if (m_pCurrentSessionData != nullptr) + { + m_traceStatus = TraceStatus::Aborting; + } + else + { + // The client that requested the trace has disconnected. Discard the trace. + m_traceStatus = TraceStatus::Idle; + } + + result = Result::Success; + } + + return result; + } + + Result RGPServer::WriteTraceData(const uint8* pTraceData, size_t traceDataSize) + { + Result result = Result::Error; + + Platform::LockGuard lock(m_mutex); + + // Make sure there is a trace running. + if (m_traceStatus == TraceStatus::Running) + { + size_t traceDataRemaining = traceDataSize; + + if (m_pCurrentSessionData != nullptr) + { + m_pCurrentSessionData->traceSizeInBytes += traceDataSize; + while (traceDataRemaining > 0) + { + RGPPayload *pPayload = m_pCurrentSessionData->chunkPayloads.AllocateBack(); + if (pPayload != nullptr) + { + const size_t dataSize = ((traceDataRemaining < kMaxTraceDataChunkSize) ? traceDataRemaining + : kMaxTraceDataChunkSize); + + memcpy(pPayload->traceDataChunk.chunk.data, pTraceData, dataSize); + pPayload->traceDataChunk.chunk.dataSize = static_cast(dataSize); + pPayload->command = RGPMessage::TraceDataChunk; + + pTraceData += dataSize; + traceDataRemaining -= dataSize; + } + else + { + break; + } + } + } + + if (traceDataRemaining == 0) + result = Result::Success; + } + + DD_ASSERT(result == Result::Success); + return result; + } + + ProfilingStatus RGPServer::QueryProfilingStatus() + { + Platform::LockGuard lock(m_mutex); + + const ProfilingStatus profilingStatus = m_profilingStatus; + + return profilingStatus; + } + + ServerTraceParametersInfo RGPServer::QueryTraceParameters() + { + Platform::LockGuard lock(m_mutex); + + const ServerTraceParametersInfo traceParameters = m_traceParameters; + + return traceParameters; + } + + void RGPServer::LockData() + { + m_mutex.Lock(); + } + + void RGPServer::UnlockData() + { + m_mutex.Unlock(); + } + + void RGPServer::ClearCurrentSession() + { + if (m_pCurrentSessionData != nullptr) + { + // Move back to idle state and reset all state if we have a valid session. + m_traceStatus = TraceStatus::Idle; + m_pCurrentSessionData->state = SessionState::ReceivePayload; + m_pCurrentSessionData->version = 0; + m_pCurrentSessionData->traceSizeInBytes = 0; + m_pCurrentSessionData->chunkPayloads.Clear(); + m_pCurrentSessionData->abortRequestedByClient = false; + m_pCurrentSessionData = nullptr; + } + } + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/settingsClient.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/settingsClient.cpp new file mode 100644 index 000000000..8b5709eaa --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/settingsClient.cpp @@ -0,0 +1,299 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "protocols/settingsClient.h" +#include "msgChannel.h" +#include + +namespace DevDriver +{ + namespace SettingsProtocol + { + + SettingsClient::SettingsClient(IMsgChannel* pMsgChannel) + : BaseProtocolClient(pMsgChannel, Protocol::Settings, SETTINGS_CLIENT_MIN_MAJOR_VERSION, SETTINGS_CLIENT_MAX_MAJOR_VERSION) + + { + } + + SettingsClient::~SettingsClient() + { + } + + Result SettingsClient::QueryNumSettings(uint32* pNumSettings) + { + Result result = Result::Error; + + if (IsConnected() && (pNumSettings != nullptr)) + { + SettingsPayload payload = {}; + payload.command = SettingsMessage::QueryNumSettingsRequest; + + result = SendPayload(payload); + if (result == Result::Success) + { + result = ReceivePayload(payload); + } + + if (result == Result::Success) + { + if (payload.command == SettingsMessage::QueryNumSettingsResponse) + { + *pNumSettings = payload.queryNumSettingsResponse.numSettings; + } + else + { + // Invalid response payload + result = Result::Error; + } + } + } + + return result; + } + + Result SettingsClient::QuerySettings(Setting* pSettingsBuffer, uint32 bufferSizeInSettings) + { + Result result = Result::Error; + + if (IsConnected() && (pSettingsBuffer != nullptr) && (bufferSizeInSettings > 0)) + { + SettingsPayload payload = {}; + payload.command = SettingsMessage::QuerySettingsRequest; + + result = SendPayload(payload); + if (result == Result::Success) + { + result = ReceivePayload(payload); + } + + if (result == Result::Success) + { + if (payload.command == SettingsMessage::QuerySettingsNumResponse) + { + uint32 settingsSent = payload.querySettingsNumResponse.numSettings; + uint32 settingsReceived = 0; + for (uint32 settingIndex = 0; settingIndex < settingsSent; ++settingIndex) + { + result = ReceivePayload(payload); + if (result == Result::Success) + { + if (payload.command == SettingsMessage::QuerySettingsDataResponse) + { + if (settingsReceived < bufferSizeInSettings) + { + memcpy(pSettingsBuffer + settingsReceived, &payload.querySettingsDataResponse.setting, sizeof(Setting)); + ++settingsReceived; + } + } + else + { + // Invalid response payload + result = Result::Error; + break; + } + } + else + { + break; + } + } + } + else + { + // Invalid response payload + result = Result::Error; + } + } + } + + return result; + } + + Result SettingsClient::QuerySetting(const char* pName, Setting* pSetting) + { + Result result = Result::Error; + + if (IsConnected() && (pName != nullptr) && (pSetting != nullptr)) + { + SettingsPayload payload = {}; + payload.command = SettingsMessage::QuerySettingRequest; + Platform::Strncpy(payload.querySettingRequest.name, pName, sizeof(payload.querySettingRequest.name)); + + result = SendPayload(payload); + if (result == Result::Success) + { + result = ReceivePayload(payload); + } + + if (result == Result::Success) + { + if (payload.command == SettingsMessage::QuerySettingResponse) + { + if (payload.querySettingResponse.success) + { + memcpy(pSetting, &payload.querySettingResponse.setting, sizeof(Setting)); + } + else + { + // The connected client failed to set the requested setting + result = Result::Error; + } + } + else + { + // Invalid response payload + result = Result::Error; + } + } + } + + return result; + } + + Result SettingsClient::SetSetting(const char* pName, const SettingValue* pValue) + { + Result result = Result::Error; + + if (IsConnected() && (pName != nullptr) && (pValue != nullptr)) + { + SettingsPayload payload = {}; + payload.command = SettingsMessage::SetSettingRequest; + Platform::Strncpy(payload.setSettingRequest.name, pName, sizeof(payload.setSettingRequest.name)); + memcpy(&payload.setSettingRequest.value, pValue, sizeof(SettingValue)); + + result = SendPayload(payload); + if (result == Result::Success) + { + result = ReceivePayload(payload); + } + + if (result == Result::Success) + { + if (payload.command == SettingsMessage::SetSettingResponse) + { + result = (payload.setSettingResponse.success ? Result::Success : Result::Error); + } + else + { + // Invalid response payload + result = Result::Error; + } + } + } + + return result; + } + + Result SettingsClient::QueryNumCategories(uint32* pNumCategories) + { + Result result = Result::Error; + + if (IsConnected() && (pNumCategories != nullptr)) + { + SettingsPayload payload = {}; + payload.command = SettingsMessage::QueryNumCategoriesRequest; + + result = SendPayload(payload); + if (result == Result::Success) + { + result = ReceivePayload(payload); + } + + if (result == Result::Success) + { + if (payload.command == SettingsMessage::QueryNumCategoriesResponse) + { + *pNumCategories = payload.queryNumCategoriesResponse.numCategories; + } + else + { + // Invalid response payload + result = Result::Error; + } + } + } + + return result; + } + + Result SettingsClient::QueryCategories(SettingCategory* pCategoriesBuffer, uint32 bufferSizeInCategories) + { + Result result = Result::Error; + + if (IsConnected() && (pCategoriesBuffer != nullptr) && (bufferSizeInCategories > 0)) + { + SettingsPayload payload = {}; + payload.command = SettingsMessage::QueryCategoriesRequest; + + result = SendPayload(payload); + if (result == Result::Success) + { + result = ReceivePayload(payload); + } + + if (result == Result::Success) + { + if (payload.command == SettingsMessage::QueryCategoriesNumResponse) + { + uint32 categoriesSent = payload.queryCategoriesNumResponse.numCategories; + uint32 categoriesReceived = 0; + for (uint32 categoryIndex = 0; categoryIndex < categoriesSent; ++categoryIndex) + { + result = ReceivePayload(payload); + if (result == Result::Success) + { + if (payload.command == SettingsMessage::QueryCategoriesDataResponse) + { + if (categoriesReceived < bufferSizeInCategories) + { + memcpy(pCategoriesBuffer + categoriesReceived, &payload.queryCategoriesDataResponse.category, sizeof(SettingCategory)); + ++categoriesReceived; + } + } + else + { + // Invalid response payload + result = Result::Error; + break; + } + } + else + { + break; + } + } + } + else + { + // Invalid response payload + result = Result::Error; + } + } + } + + return result; + } + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/settingsServer.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/settingsServer.cpp new file mode 100644 index 000000000..b6e81d6f6 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/protocols/settingsServer.cpp @@ -0,0 +1,541 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "protocols/settingsServer.h" +#include "msgChannel.h" +#include + +namespace DevDriver +{ + namespace SettingsProtocol + { + enum class SessionState + { + ReceivePayload = 0, + ProcessPayload, + SendPayload, + SendSettingsNumResponse, + SendSettingsDataResponse, + SendCategoriesNumResponse, + SendCategoriesDataResponse + }; + + struct SettingsSession + { + SessionState state; + SettingsPayload payload; + uint32 itemIndex; + uint32 numItems; + }; + + SettingsServer::SettingsServer(IMsgChannel* pMsgChannel) + : BaseProtocolServer(pMsgChannel, Protocol::Settings, SETTINGS_CLIENT_MIN_MAJOR_VERSION, SETTINGS_CLIENT_MAX_MAJOR_VERSION) + , m_settings(pMsgChannel->GetAllocCb()) + , m_categories(pMsgChannel->GetAllocCb()) + { + DD_ASSERT(m_pMsgChannel != nullptr); + } + + SettingsServer::~SettingsServer() + { + } + + void SettingsServer::Finalize() + { + LockData(); + BaseProtocolServer::Finalize(); + UnlockData(); + } + + bool SettingsServer::AcceptSession(const SharedPointer& pSession) + { + DD_UNUSED(pSession); + return true; + } + + void SettingsServer::SessionEstablished(const SharedPointer& pSession) + { + DD_UNUSED(pSession); + + // Allocate session data for the newly established session + SettingsSession* pSessionData = DD_NEW(SettingsSession, m_pMsgChannel->GetAllocCb())(); + pSessionData->state = SessionState::ReceivePayload; + pSessionData->payload = {}; + pSession->SetUserData(pSessionData); + } + + void SettingsServer::UpdateSession(const SharedPointer& pSession) + { + SettingsSession* pSessionData = reinterpret_cast(pSession->GetUserData()); + + switch (pSessionData->state) + { + case SessionState::ReceivePayload: + { + uint32 bytesReceived = 0; + Result result = pSession->Receive(sizeof(pSessionData->payload), &pSessionData->payload, &bytesReceived, kNoWait); + + if (result == Result::Success) + { + DD_ASSERT(sizeof(pSessionData->payload) == bytesReceived); + pSessionData->state = SessionState::ProcessPayload; + } + + break; + } + + case SessionState::ProcessPayload: + { + switch (static_cast(pSessionData->payload.command)) + { + case SettingsMessage::QueryNumSettingsRequest: + { + LockData(); + const uint32 numSettings = static_cast(m_settings.Size()); + UnlockData(); + + pSessionData->payload.command = SettingsMessage::QueryNumSettingsResponse; + pSessionData->payload.queryNumSettingsResponse.numSettings = numSettings; + + pSessionData->state = SessionState::SendPayload; + + break; + } + case SettingsMessage::QuerySettingsRequest: + { + LockData(); + const uint32 numSettings = static_cast(m_settings.Size()); + UnlockData(); + + pSessionData->payload.command = SettingsMessage::QuerySettingsNumResponse; + pSessionData->payload.querySettingsNumResponse.numSettings = numSettings; + + pSessionData->state = SessionState::SendSettingsNumResponse; + + break; + } + case SettingsMessage::QuerySettingRequest: + { + pSessionData->payload.command = SettingsMessage::QuerySettingResponse; + pSessionData->payload.querySettingResponse.success = false; + + LockData(); + int32 settingIndex = FindSetting(pSessionData->payload.querySettingRequest.name); + if (settingIndex != -1) + { + pSessionData->payload.querySettingResponse.success = true; + memcpy(&pSessionData->payload.querySettingResponse.setting, &m_settings[settingIndex], sizeof(Setting)); +#if SETTINGS_PROTOCOL_SUPPORTS(SETTINGS_HEX_VERSION) + if ((pSession->GetVersion() < SETTINGS_HEX_VERSION) & (pSessionData->payload.querySettingResponse.setting.type == SettingType::Hex)) + { + pSessionData->payload.querySettingResponse.setting.type = SettingType::UnsignedInteger; + } +#endif + } + UnlockData(); + + pSessionData->state = SessionState::SendPayload; + + break; + } + case SettingsMessage::SetSettingRequest: + { + Setting* pSetting = nullptr; + + LockData(); + + if (m_isFinalized == false) + { + for (auto &setting : m_settings) + { + if (strcmp(setting.name, pSessionData->payload.setSettingRequest.name) == 0) + { + pSetting = &setting; + break; + } + } + + if (pSetting != nullptr) + { + memcpy(&pSetting->value, &pSessionData->payload.setSettingRequest.value, sizeof(SettingValue)); + } + } + UnlockData(); + + pSessionData->payload.command = SettingsMessage::SetSettingResponse; + pSessionData->payload.setSettingResponse.success = (pSetting != nullptr); + + pSessionData->state = SessionState::SendPayload; + + break; + } + case SettingsMessage::QueryNumCategoriesRequest: + { + LockData(); + const uint32 numCategories = static_cast(m_categories.Size()); + UnlockData(); + + pSessionData->payload.command = SettingsMessage::QueryNumCategoriesResponse; + pSessionData->payload.queryNumCategoriesResponse.numCategories = numCategories; + + pSessionData->state = SessionState::SendPayload; + + break; + } + case SettingsMessage::QueryCategoriesRequest: + { + LockData(); + const uint32 numCategories = static_cast(m_categories.Size()); + UnlockData(); + + pSessionData->payload.command = SettingsMessage::QueryCategoriesNumResponse; + pSessionData->payload.queryCategoriesNumResponse.numCategories = numCategories; + + pSessionData->state = SessionState::SendCategoriesNumResponse; + + break; + } + + default: + { + DD_UNREACHABLE(); + break; + } + } + + break; + } + + case SessionState::SendPayload: + { + Result result = pSession->Send(sizeof(pSessionData->payload), &pSessionData->payload, kNoWait); + if (result == Result::Success) + { + pSessionData->state = SessionState::ReceivePayload; + } + + break; + } + + case SessionState::SendSettingsNumResponse: + { + Result result = pSession->Send(sizeof(pSessionData->payload), &pSessionData->payload, kNoWait); + if (result == Result::Success) + { + pSessionData->itemIndex = 0; + pSessionData->numItems = pSessionData->payload.querySettingsNumResponse.numSettings; + pSessionData->state = SessionState::SendSettingsDataResponse; + + // Prepare the payload for the first data response + pSessionData->payload.command = SettingsMessage::QuerySettingsDataResponse; + if (pSessionData->numItems > 0) + { + LockData(); + memcpy(&pSessionData->payload.querySettingsDataResponse.setting, &m_settings[0], sizeof(Setting)); +#if SETTINGS_PROTOCOL_SUPPORTS(SETTINGS_HEX_VERSION) + if ((pSession->GetVersion() < SETTINGS_HEX_VERSION) & (pSessionData->payload.querySettingResponse.setting.type == SettingType::Hex)) + { + pSessionData->payload.querySettingsDataResponse.setting.type = SettingType::UnsignedInteger; + } +#endif + UnlockData(); + } + } + + break; + } + + case SessionState::SendSettingsDataResponse: + { + if (pSessionData->itemIndex < pSessionData->numItems) + { + while (pSession->Send(sizeof(pSessionData->payload), &pSessionData->payload, kNoWait) == Result::Success) + { + ++pSessionData->itemIndex; + + // Prepare the payload for the next data response if necessary + if (pSessionData->itemIndex < pSessionData->numItems) + { + LockData(); + memcpy(&pSessionData->payload.querySettingsDataResponse.setting, &m_settings[pSessionData->itemIndex], sizeof(Setting)); +#if SETTINGS_PROTOCOL_SUPPORTS(SETTINGS_HEX_VERSION) + if ((pSession->GetVersion() < SETTINGS_HEX_VERSION) & (pSessionData->payload.querySettingResponse.setting.type == SettingType::Hex)) + { + pSessionData->payload.querySettingsDataResponse.setting.type = SettingType::UnsignedInteger; + } +#endif + UnlockData(); + } + else + { + // Break out of the send loop if we've finished sending all of the responses + break; + } + } + } + else + { + // We've sent all the responses. Return to normal operation. + pSessionData->state = SessionState::ReceivePayload; + } + + break; + } + + case SessionState::SendCategoriesNumResponse: + { + Result result = pSession->Send(sizeof(pSessionData->payload), &pSessionData->payload, kNoWait); + if (result == Result::Success) + { + pSessionData->itemIndex = 0; + pSessionData->numItems = pSessionData->payload.queryCategoriesNumResponse.numCategories; + pSessionData->state = SessionState::SendCategoriesDataResponse; + + // Prepare the payload for the first data response + pSessionData->payload.command = SettingsMessage::QueryCategoriesDataResponse; + if (pSessionData->numItems > 0) + { + LockData(); + memcpy(&pSessionData->payload.queryCategoriesDataResponse.category, &m_categories[0], sizeof(SettingCategory)); + UnlockData(); + } + } + + break; + } + + case SessionState::SendCategoriesDataResponse: + { + if (pSessionData->itemIndex < pSessionData->numItems) + { + while (pSession->Send(sizeof(pSessionData->payload), &pSessionData->payload, kNoWait) == Result::Success) + { + ++pSessionData->itemIndex; + + // Prepare the payload for the next data response if necessary + if (pSessionData->itemIndex < pSessionData->numItems) + { + LockData(); + memcpy(&pSessionData->payload.queryCategoriesDataResponse.category, &m_categories[pSessionData->itemIndex], sizeof(SettingCategory)); + UnlockData(); + } + else + { + // Break out of the send loop if we've finished sending all of the responses + break; + } + } + } + else + { + // We've sent all the responses. Return to normal operation. + pSessionData->state = SessionState::ReceivePayload; + } + + break; + } + + default: + { + DD_UNREACHABLE(); + break; + } + } + } + + void SettingsServer::SessionTerminated(const SharedPointer& pSession, Result terminationReason) + { + DD_UNUSED(terminationReason); + SettingsSession *pSettingsSession = reinterpret_cast(pSession->SetUserData(nullptr)); + + // Free the session data + if (pSettingsSession != nullptr) + { + DD_DELETE(pSettingsSession, m_pMsgChannel->GetAllocCb()); + } + } + + void SettingsServer::AddCategory(const char* pName, const char* pParentName) + { + int32 categoryIndex = FindCategory(pName); + + // Make sure we don't already have this category + if (categoryIndex == -1) + { + // Default to the root category if no parent name is provided + int32 parentCategoryIndex = -1; + if (pParentName != nullptr) + { + parentCategoryIndex = FindCategory(pParentName); + + // Make sure the parent category name is valid + DD_ASSERT(parentCategoryIndex != -1); + } + + SettingCategory category = {}; + Platform::Strncpy(category.name, pName, sizeof(category.name)); + category.parentIndex = parentCategoryIndex; + + m_categories.PushBack(category); + } + } + + int32 SettingsServer::QueryCategoryIndex(const char* pName) const + { + return FindCategory(pName); + } + + void SettingsServer::AddSetting(const Setting* pSetting) + { + DD_ASSERT(pSetting != nullptr); + + // Make sure the setting refers to a valid category index + DD_ASSERT(pSetting->categoryIndex < static_cast(m_categories.Size())); + + LockData(); + m_settings.PushBack(*pSetting); + UnlockData(); + } + + bool SettingsServer::QuerySetting(const char* pName, Setting* pSetting) + { + LockData(); + int32 settingIndex = FindSetting(pName); + if (settingIndex != -1) + { + memcpy(pSetting, &m_settings[settingIndex], sizeof(Setting)); + } + UnlockData(); + + return (settingIndex != -1); + } + + bool SettingsServer::QuerySettingByIndex(uint32 settingIndex, Setting* pSetting) + { + bool result = false; + + LockData(); + if (settingIndex < m_settings.Size()) + { + memcpy(pSetting, &m_settings[settingIndex], sizeof(Setting)); + result = true; + } + UnlockData(); + + return result; + } + + bool SettingsServer::UpdateSetting(const char* pName, const SettingValue* pValue) + { + LockData(); + int32 settingIndex = FindSetting(pName); + if (settingIndex != -1) + { + memcpy(&m_settings[settingIndex].value, pValue, sizeof(SettingValue)); + } + UnlockData(); + + return (settingIndex != -1); + } + + bool SettingsServer::UpdateSettingByIndex(uint32 settingIndex, const SettingValue* pValue) + { + bool result = false; + + LockData(); + if (settingIndex < m_settings.Size()) + { + memcpy(&m_settings[settingIndex].value, pValue, sizeof(SettingValue)); + result = true; + } + UnlockData(); + + return result; + } + + uint32 SettingsServer::GetNumSettings() + { + LockData(); + uint32 numSettings = static_cast(m_settings.Size()); + UnlockData(); + + return numSettings; + } + + uint32 SettingsServer::GetNumCategories() + { + LockData(); + uint32 numCategories = static_cast (m_categories.Size()); + UnlockData(); + + return numCategories; + } + + void SettingsServer::LockData() + { + m_mutex.Lock(); + } + + void SettingsServer::UnlockData() + { + m_mutex.Unlock(); + } + + int32 SettingsServer::FindCategory(const char* pCategoryName) const + { + DD_ASSERT(pCategoryName != nullptr); + + int32 targetCategoryIndex = -1; + + for (uint32 categoryIndex = 0; categoryIndex < static_cast(m_categories.Size()); ++categoryIndex) + { + if (strcmp(m_categories[categoryIndex].name, pCategoryName) == 0) + { + targetCategoryIndex = static_cast(categoryIndex); + break; + } + } + + return targetCategoryIndex; + } + + int32 SettingsServer::FindSetting(const char* pSettingName) const + { + DD_ASSERT(pSettingName != nullptr); + + int32 targetSettingIndex = -1; + + for (uint32 settingIndex = 0; settingIndex < static_cast(m_settings.Size()); ++settingIndex) + { + if (strcmp(m_settings[settingIndex].name, pSettingName) == 0) + { + targetSettingIndex = static_cast(settingIndex); + break; + } + } + + return targetSettingIndex; + } + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/session.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/session.cpp new file mode 100644 index 000000000..ca0f57154 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/session.cpp @@ -0,0 +1,949 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "session.h" +#include "sessionManager.h" +#include "msgChannel.h" +#include "protocolServer.h" +#include "protocolClient.h" +#include +#include + +#if !defined(NDEBUG) && !defined(DEVDRIVER_SHOW_SYMBOLS) +#define DEVDRIVER_SHOW_SYMBOLS +#endif + +using namespace DevDriver::SessionProtocol; +using namespace DevDriver::Platform; + +namespace DevDriver +{ +#if defined(DEVDRIVER_SHOW_SYMBOLS) + static_assert(static_cast(SessionState::Closed) == 0, "Unexpected SessionState::Closed value."); + static_assert(static_cast(SessionState::Listening) == 1, "Unexpected SessionState::Listening value."); + static_assert(static_cast(SessionState::SynSent) == 2, "Unexpected SessionState::SynSent value."); + static_assert(static_cast(SessionState::SynReceived) == 3, "Unexpected SessionState::SynReceived value."); + static_assert(static_cast(SessionState::Established) == 4, "Unexpected SessionState::Established value."); + static_assert(static_cast(SessionState::FinWait1) == 5, "Unexpected SessionState::FinWait1 value."); + static_assert(static_cast(SessionState::Closing) == 6, "Unexpected SessionState::Closing value."); + static_assert(static_cast(SessionState::FinWait2) == 7, "Unexpected SessionState::FinWait2 value."); + static_assert(static_cast(SessionState::Count) == 8, "Unexpected SessionState::Count value."); + + DD_STATIC_CONST const char* kStateName[static_cast(SessionState::Count)] = + { + "Closed", // Closed + "Listening", // Listening + "SynSent", // SynSent + "SynReceived", // SynReceived + "Established", // Established + "FinWait1", // FinWait1 + "Closing", // Closing + "FinWait2", // FinWait2 + }; +#endif + + DD_STATIC_CONST uint32 kMaxRetransmits = 5; + DD_STATIC_CONST float kMovingAverageWindow = 2; + DD_STATIC_CONST float kAlpha = 2.0f / (kMovingAverageWindow + 1.0f); + DD_STATIC_CONST uint32 kFastRetransmitThreshold = 3; + DD_STATIC_CONST float kMinRetransmitDelay = 100.0f; + DD_STATIC_CONST float kMaxRetransmitDelay = 2000.0f; + DD_STATIC_CONST uint32 kMaxUnacknowledgedThreshold = 5; + + Session::Session(IMsgChannel* pMsgChannel) : + m_pMsgChannel(pMsgChannel), + m_pProtocolOwner(nullptr), + m_pSessionUserdata(nullptr), + m_clientId(pMsgChannel->GetClientId()), + m_remoteClientId(kBroadcastClientId), + m_sessionId(kInvalidSessionId), + m_sessionState(SessionState::Closed), + m_sessionTerminationReason(Result::Success), + m_protocolVersion(0), + m_sessionVersion(kSessionProtocolVersion) + { + } + + // Transmits a message and closes the session on error. This helps catches instances where the underlying transport + // has disconnected. + bool Session::SendOrClose(const MessageBuffer& messageBuffer) + { + bool result = true; + Result sendResult; + do + { + sendResult = m_pMsgChannel->Forward(messageBuffer); + } while (sendResult == Result::NotReady); + + if (sendResult != Result::Success) + { + Shutdown(Result::Error); + result = false; + } + return result; + } + + bool Session::SendControlMessage(SessionMessage command, Sequence sequenceNumber) + { + MessageBuffer messageBuffer = {}; + messageBuffer.header.dstClientId = m_remoteClientId; + messageBuffer.header.srcClientId = m_clientId; + messageBuffer.header.protocolId = Protocol::Session; + messageBuffer.header.messageId = static_cast(command); + messageBuffer.header.sessionId = m_sessionId; + messageBuffer.header.sequence = sequenceNumber; + messageBuffer.header.payloadSize = 0; + messageBuffer.header.windowSize = m_receiveWindow.currentAvailableSize; + + return SendOrClose(messageBuffer); + } + + bool Session::SendAckMessage() + { + // transmit an ack based on the current max sequence received + const Sequence& seq = m_receiveWindow.nextExpectedSequence; + m_receiveWindow.lastUnacknowledgedSequence = seq; + m_receiveWindow.currentAvailableSize = CalculateCurrentWindowSize(); + return SendControlMessage(SessionMessage::Ack, (seq - 1)); + } + + Result Session::MarkMessagesAsAcknowledged(Sequence maxSequenceNumber) + { + Result result = Result::Error; + + LockGuard lock(m_sendWindow.lock); + + Sequence seq = m_sendWindow.nextUnacknowledgedSequence; + const uint64 currentTime = Platform::GetCurrentTimeInMs(); + float currentAverage = m_sendWindow.roundTripTime; + + // the first pass goes through and invalidates all packets that have been acknowledged + while (seq <= Min(maxSequenceNumber, m_sendWindow.lastSentSequence)) + { + const Sequence index = seq % m_sendWindow.GetWindowSize(); + + DD_ASSERT(m_sendWindow.valid[index] == true && m_sendWindow.sequence[index] == seq); + if ((m_sendWindow.valid[index] != true) | (m_sendWindow.sequence[index] != seq)) + break; + + m_sendWindow.valid[index] = false; + + // if we aren't in the middle of retransmit, feel free to use this as part of the round trip time + if (m_sendWindow.retransmitCount == 0) + { + const uint64 elapsedTimeInMs = currentTime - m_sendWindow.initialTransmitTimeInMs[index]; + currentAverage = (kAlpha * elapsedTimeInMs) + ((1.0f - kAlpha) * currentAverage); + } + + DD_ASSERT((m_sendWindow.nextSequence - seq) <= m_sendWindow.GetWindowSize()); + + m_sendWindow.semaphore.Signal(); + seq++; + } + + // if we acknowledged any new packets this time + if (m_sendWindow.nextUnacknowledgedSequence < seq) + { + result = Result::Success; + + DD_PRINT(LogLevel::Debug, "Current round trip time: %0.2f", currentAverage); + // housekeeping + m_sendWindow.roundTripTime = currentAverage; + m_sendWindow.retransmitCount = 0; + m_sendWindow.nextUnacknowledgedSequence = seq; + m_sendWindow.lastAckCount = 0; + + } + else if (m_sendWindow.nextUnacknowledgedSequence == seq) + { + // handle case MarkMessagesAsAcknowledged was called we didn't actually mark any messages as acknowledged + // This typically means that a packet was dropped and the other host has started retransmitting duplicate + // ack packets + m_sendWindow.lastAckCount++; + + // if we've passed the fast retransmit threshold we need to automatically start retransmitting data + // we start at the first unacknowledged packet, and retransmit one additional packet for every duplicate we + // receive + if (m_sendWindow.lastAckCount >= kFastRetransmitThreshold) + { + // calculate the nextSequence number for the packet to retransmit + const Sequence retransSeq = m_sendWindow.nextUnacknowledgedSequence + + (m_sendWindow.lastAckCount - kFastRetransmitThreshold); + + DD_PRINT(LogLevel::Debug, "FAST RETRANS session %u seq %u", m_sessionId, retransSeq); + + // Calculate the index for the packet to be retransmitted + const Sequence index = retransSeq % m_sendWindow.GetWindowSize(); + + // Re-write the window size in the retransmitted packet + m_sendWindow.messages[index].header.windowSize = m_receiveWindow.currentAvailableSize; + + if (SendOrClose(m_sendWindow.messages[index])) + { + // If we successfully transmitted this we want to reset the transmit count so that regular + // retransmit doesn't take affect + m_sendWindow.retransmitCount = 0; + } + } + } + return result; + } + + Result Session::WriteMessageIntoReceiveWindow(const MessageBuffer& messageBuffer) + { + DD_PRINT(LogLevel::Debug, + "Attempting to write message with seq %u into session %u's receive window", + messageBuffer.header.sequence, + m_sessionId); + + Result result = Result::Error; + LockGuard lock(m_receiveWindow.lock); + + Sequence nextSequence = m_receiveWindow.nextExpectedSequence; + + // check to see if we have any unacknowledged data in the receive window + const bool pendingAck = (nextSequence > m_receiveWindow.lastUnacknowledgedSequence); + + if ((messageBuffer.header.sequence >= nextSequence) + & (messageBuffer.header.payloadSize <= kMaxPayloadSizeInBytes)) + { + const Sequence distance = (messageBuffer.header.sequence - m_receiveWindow.nextUnreadSequence); + + if (distance < m_receiveWindow.GetWindowSize()) + { + DD_PRINT(LogLevel::Debug, + "Session %u received message sq %u", + m_sessionId, + messageBuffer.header.sequence); + + // Send the request. + const uint32 index = messageBuffer.header.sequence % m_receiveWindow.GetWindowSize(); + + // DD_ASSERT(m_receiveWindow.valid[index] == false); + + // copy data + set associated state + memcpy(&m_receiveWindow.messages[index], + &messageBuffer, + sizeof(MessageHeader) + messageBuffer.header.payloadSize); + + m_receiveWindow.sequence[index] = messageBuffer.header.sequence; + m_receiveWindow.valid[index] = true; + + // Step the sequence number forward until we find an invalid packet or finish scanning the entire window. + while ((nextSequence - m_receiveWindow.nextUnreadSequence) < m_receiveWindow.GetWindowSize()) + { + if (m_receiveWindow.valid[nextSequence % m_receiveWindow.GetWindowSize()]) + { + // Increment the sequence number since this is a valid packet + nextSequence++; + DD_ASSERT(m_receiveWindow.nextUnreadSequence != nextSequence); + m_receiveWindow.semaphore.Signal(); + } else + { + // Break out since we found an invalid packet + break; + } + } + + m_receiveWindow.nextExpectedSequence = nextSequence; + + // if we already have data waiting we want to ack in two conditions + // 1) if too many packets have not been acknowledged + // 2) if we have waited more than half of the a round trip time + // This is to prevent situations where a client retransmits a bunch of data unnecessarily + if (pendingAck) + { + const uint64 unackDistance = (nextSequence - m_receiveWindow.lastUnacknowledgedSequence); + if (unackDistance >= kMaxUnacknowledgedThreshold) + { + DD_PRINT(LogLevel::Debug, "Early ack seq %u", (nextSequence - 1)); + SendAckMessage(); + } + } + result = Result::Success; + } + } + else + { + // if this data arrived out of order or was retransmitted + // we go ahead and send a new acknowledgment now without waiting + if (!pendingAck) + { + DD_PRINT(LogLevel::Debug, "Reack seq %u", (nextSequence - 1)); + } + SendAckMessage(); + result = Result::Success; + } + return result; + } + + Result Session::WriteMessageIntoSendWindow( + SessionMessage message, + uint32 payloadSizeInBytes, + const void* pPayload, uint32 timeoutInMs) + { + Result result = Result::Error; + + if (m_sessionState < SessionState::FinWait2) + { + if (payloadSizeInBytes <= kMaxPayloadSizeInBytes) + { + result = m_sendWindow.semaphore.Wait(timeoutInMs); + + if (result == Result::Success) + { + LockGuard lock(m_sendWindow.lock); + + const Sequence distance = m_sendWindow.nextSequence - m_sendWindow.nextUnacknowledgedSequence; + DD_UNUSED(distance); + DD_ASSERT(distance < m_sendWindow.GetWindowSize()); + + const Sequence seq = m_sendWindow.nextSequence; + ++m_sendWindow.nextSequence; + + DD_PRINT(LogLevel::Never, "Sending a message with sequence number %u", seq); + DD_PRINT(LogLevel::Never, "Next sequence number %u", m_sendWindow.nextSequence); + + const Sequence index = seq % m_sendWindow.GetWindowSize(); + + DD_ASSERT(m_sendWindow.valid[index] == false); + DD_ASSERT((payloadSizeInBytes > 0 && pPayload != nullptr) || (pPayload == nullptr && payloadSizeInBytes == 0)); + + MessageBuffer& messageBuffer = m_sendWindow.messages[index]; + // Set up the message header. + messageBuffer.header.srcClientId = m_clientId; + messageBuffer.header.dstClientId = m_remoteClientId; + messageBuffer.header.protocolId = Protocol::Session; + messageBuffer.header.messageId = static_cast(message); + messageBuffer.header.sessionId = m_sessionId; + messageBuffer.header.windowSize = m_receiveWindow.currentAvailableSize; + messageBuffer.header.sequence = seq; + + if ((pPayload != nullptr) & (payloadSizeInBytes > 0)) + { + memcpy(&messageBuffer.payload[0], pPayload, payloadSizeInBytes); + messageBuffer.header.payloadSize = payloadSizeInBytes; + } + else + { + messageBuffer.header.payloadSize = 0; + } + + m_sendWindow.sequence[index] = seq; + m_sendWindow.valid[index] = true; + } + } + else + { + result = Result::InsufficientMemory; + } + } + return result; + } + + Result Session::Connect(IProtocolClient& owner, + ClientId remoteClientId, + SessionId sessionId) + { + Result result = Result::Error; + + // A session can only connect to a remote session if: + // 1) The provided object is indeed a Client object + // 2) The remote client ID provided is not a broadcast client ID + // 3) The session ID provided is not invalid + // 4) The session is in the closed state + if ((owner.GetType() == SessionType::Client) && + (remoteClientId != kBroadcastClientId) && + (sessionId != kInvalidSessionId) && + (m_sessionState == SessionState::Closed)) + { + m_pProtocolOwner = &owner; + m_remoteClientId = remoteClientId; + m_sessionId = sessionId; + + // Write the payload data for a session request packet. + SynPayload payload = {}; + payload.protocol = m_pProtocolOwner->GetProtocol(); + payload.minVersion = m_pProtocolOwner->GetMinVersion(); + payload.maxVersion = m_pProtocolOwner->GetMaxVersion(); + payload.sessionVersion = m_sessionVersion; + result = WriteMessageIntoSendWindow(SessionMessage::Syn, sizeof(SynPayload), &payload, kInfiniteTimeout); + + if (result == Result::Success) + { + SetState(SessionState::SynSent); + } + } + return result; + } + + Result Session::BindToServer(IProtocolServer& owner, + ClientId remoteClientId, + SessionVersion sessionVersion, + Version protocolVersion, + SessionId sessionId) + { + Result result = Result::Error; + + // We can only bind to a protocol server if: + // 1) The provided object is indeed a Server object + // 2) The remote client ID provided is not a broadcast client ID + // 3) The session ID provided is not invalid + // 4) The session is in the closed state + if ((owner.GetType() == SessionType::Server) && + (remoteClientId != kBroadcastClientId) && + (sessionId != kInvalidSessionId) && + (m_sessionState == SessionState::Closed)) + { + m_pProtocolOwner = &owner; + m_remoteClientId = remoteClientId; + m_sessionVersion = Platform::Min(sessionVersion, kSessionProtocolVersion); + m_protocolVersion = protocolVersion; + m_sessionId = sessionId; + SetState(SessionState::Listening); + result = Result::Success; + } + return result; + } + + void Session::HandleMessage(SharedPointer& pSession, const MessageBuffer& messageBuffer) + { + const SessionState initialState = GetSessionState(); + switch (static_cast(messageBuffer.header.messageId)) + { + case SessionMessage::Syn: + HandleSynMessage(messageBuffer); + break; + case SessionMessage::SynAck: + HandleSynAckMessage(messageBuffer); + break; + case SessionMessage::Fin: + HandleFinMessage(messageBuffer); + break; + case SessionMessage::Data: + HandleDataMessage(messageBuffer); + break; + case SessionMessage::Ack: + HandleAckMessage(messageBuffer); + break; + case SessionMessage::Rst: + HandleRstMessage(messageBuffer); + break; + default: + DD_UNREACHABLE(); + break; + } + + // If the message caused a state change, we need to process the state transition. For now, that is only + // issuing the session established callback. + if (initialState != m_sessionState) + { + switch (m_sessionState) + { + case SessionState::Established: + { + if (m_pProtocolOwner != nullptr) + { + m_pProtocolOwner->SessionEstablished(pSession); + } + else + { + Shutdown(Result::Error); + } + } + break; + default: + break; + } + } + } + + void Session::HandleSynMessage(const MessageBuffer& messageBuffer) + { + DD_ASSERT(m_pProtocolOwner->GetType() == SessionType::Server); + + const SessionId& remoteSessionId = messageBuffer.header.sessionId; + const Sequence& receiveSequence = messageBuffer.header.sequence; + + // Write the payload data for a session request packet. + SynAckPayload payload = {}; + payload.initialSessionId = remoteSessionId; + payload.sequence = receiveSequence; + payload.version = m_protocolVersion; + payload.sessionVersion = m_sessionVersion; + const Result result = WriteMessageIntoSendWindow(SessionMessage::SynAck, + sizeof(SynAckPayload), + &payload, + kInfiniteTimeout); + if (result == Result::Success) + { + SetState(SessionState::SynReceived); + m_receiveWindow.nextUnreadSequence = receiveSequence + 1; + m_receiveWindow.nextExpectedSequence = receiveSequence + 1; + m_receiveWindow.lastUnacknowledgedSequence = receiveSequence + 1; + m_receiveWindow.currentAvailableSize = m_receiveWindow.MaxAdvertizedSize(); + } + else + { + Shutdown(Result::Error); + } + } + + void Session::HandleSynAckMessage(const MessageBuffer& messageBuffer) + { + switch (m_sessionState) + { + // These should not happen during normal operation, but in if they do we need to handle it + case SessionState::FinWait1: + case SessionState::FinWait2: + case SessionState::Closing: + // Established is the expected case here + case SessionState::Established: + MarkMessagesAsAcknowledged(messageBuffer.header.sequence); + break; + case SessionState::SynSent: + { + // A client has sent a response back from an earlier session request. + // Find the local session data. + DD_PRINT(LogLevel::Debug, "Received SYNACK"); + // The local session data's remote client id should always match the sender's id. + const SynAckPayload* DD_RESTRICT pPayload = reinterpret_cast(&messageBuffer.payload[0]); + + MarkMessagesAsAcknowledged(pPayload->sequence); + + m_sessionVersion = pPayload->sessionVersion; + DD_PRINT(LogLevel::Debug, "Established session with session version %u\n", m_sessionVersion); + DD_PRINT(LogLevel::Debug, "Acknowledging SYNACK packet %u", messageBuffer.header.sequence); + + SetState(SessionState::Established); + + // Update our remote session id in the local session data. + m_sessionId = messageBuffer.header.sessionId; + if (pPayload->version != 0) + { + m_protocolVersion = pPayload->version; + } + else if (m_pProtocolOwner != nullptr) + { + m_protocolVersion = m_pProtocolOwner->GetMinVersion(); + } + + m_receiveWindow.nextUnreadSequence = messageBuffer.header.sequence + 1; + m_receiveWindow.nextExpectedSequence = messageBuffer.header.sequence + 1; + m_receiveWindow.lastUnacknowledgedSequence = messageBuffer.header.sequence + 1; + m_receiveWindow.currentAvailableSize = m_receiveWindow.MaxAdvertizedSize(); + SendAckMessage(); + break; + } + default: + break; + } + + // Update the send window size + UpdateSendWindowSize(messageBuffer); + } + + void Session::HandleFinMessage(const MessageBuffer& messageBuffer) + { + if (m_sessionState < SessionState::Closing) + { + WriteMessageIntoReceiveWindow(messageBuffer); + // Mark the session as terminated; + SetState(SessionState::Closing); + m_sessionTerminationReason = Result::Success; + } + else if (m_sessionState == SessionState::FinWait2) + { + // if we've hit this point we received a Fin message while waiting on an ack for a Fin message. + // Best thing we can do is send an acknowledgement and close the session immediately + WriteMessageIntoReceiveWindow(messageBuffer); + SendAckMessage(); + SetState(SessionState::Closed); + m_sessionTerminationReason = Result::Success; + } + // Update the send window size + UpdateSendWindowSize(messageBuffer); + } + + void Session::HandleDataMessage(const MessageBuffer& messageBuffer) + { + switch (m_sessionState) + { + case SessionState::FinWait1: // we are closing, but received data + case SessionState::FinWait2: // we are waiting for an ack but received data + case SessionState::Established: + { + WriteMessageIntoReceiveWindow(messageBuffer); + break; + } + default: + break; + } + + // Update the send window size + UpdateSendWindowSize(messageBuffer); + } + + void Session::HandleAckMessage(const MessageBuffer& messageBuffer) + { + switch (m_sessionState) + { + case SessionState::SynReceived: // SynAck was transmitted, waiting on ack + DD_PRINT(LogLevel::Debug, "Received ACK while in SYN_RECEIVED"); + SetState(SessionState::Established); + MarkMessagesAsAcknowledged(messageBuffer.header.sequence); + break; + case SessionState::Established: // Session has been established + case SessionState::FinWait1: // Session has requested a disconnect + case SessionState::FinWait2: // Session sent Fin and is waiting on ack + case SessionState::Closing: // Session has received a Fin packet and sending data + MarkMessagesAsAcknowledged(messageBuffer.header.sequence); + break; + default: + break; + } + + // Update the send window size + UpdateSendWindowSize(messageBuffer); + } + + void Session::HandleRstMessage(const MessageBuffer& messageBuffer) + { + const Result reason = static_cast(messageBuffer.header.sequence); + Shutdown(reason); + + // TODO: figure out how to propagate this back + //if (reason == Result::VersionMismatch) + //{ + // m_protocolVersion = static_cast(messageBuffer.header.windowSize); + //} + + UpdateSendWindowSize(messageBuffer); + } + + WindowSize Session::CalculateCurrentWindowSize() + { + // Make sure we don't get a negative number + DD_ASSERT(m_receiveWindow.nextExpectedSequence >= m_receiveWindow.nextUnreadSequence); + + int32 windowSize = static_cast(m_receiveWindow.MaxAdvertizedSize()) - + static_cast(m_receiveWindow.nextExpectedSequence - m_receiveWindow.nextUnreadSequence); + + // Always make sure we return atleast 1 for the window size or the sender will stop sending messages entirely. + windowSize = Platform::Max(windowSize, 1); + + return static_cast(windowSize); + } + + void Session::UpdateSendWindowSize(const MessageBuffer& messageBuffer) + { + // Update the window size based on the packet we received + LockGuard lock(m_sendWindow.lock); + m_sendWindow.lastAvailableSize = messageBuffer.header.windowSize; + } + + bool Session::IsSendWindowEmpty() + { + LockGuard lock(m_sendWindow.lock); + + // check to see if any packets we have sent have not been acknowledged + bool isEmpty = (m_sendWindow.nextUnacknowledgedSequence > m_sendWindow.lastSentSequence); + + // we also need to check to make sure there are no unsent packets + // this is necessary because on close a client will often write the Fin packet into the + // transmit window and then try to close the session before it has been able to transmit the + // data. This test enforces proper behavior, however due to separate bugs that could cause + // sessions to get stuck while closing we cannot actually enable it unless we know the + // server has the appropriate fixes. + if (m_sessionVersion >= kSessionProtocolVersionSynAckVersion) + { + isEmpty &= ((m_sendWindow.lastSentSequence + 1) == m_sendWindow.nextSequence); + } + return isEmpty; + } + + void Session::UpdateReceiveWindow() + { + LockGuard lock(m_receiveWindow.lock); + { + const Sequence& seq = m_receiveWindow.nextExpectedSequence; + if (seq > m_receiveWindow.lastUnacknowledgedSequence) + { + // if there is unacknowledged data in the receive window we need to acknowledge it + DD_PRINT(LogLevel::Never, "Acknowledging packets %u-%u", m_receiveWindow.lastUnacknowledgedSequence, (seq - 1)); + SendAckMessage(); + } + } + } + + void Session::UpdateSendWindow() + { + LockGuard lock(m_sendWindow.lock); + + // check to see if we have any data we sent that hasn't been acknowledged yet + if (m_sendWindow.nextUnacknowledgedSequence <= m_sendWindow.lastSentSequence) + { + // only do this if we haven't hit the retransmit limit yet + if (m_sendWindow.retransmitCount <= kMaxRetransmits) + { + static_assert(kMaxRetransmits <= 14, "Error, retransmitMultiplier doesn't have enough precision for requested retransmit count"); + // calculate the current timeout + // equivalent to 2 ^ (retransmitCount + 1) + const uint16 retransmitMultiplier = 2 << m_sendWindow.retransmitCount; + const float retransmitTimeout = Max(m_sendWindow.roundTripTime, kMinRetransmitDelay); + const uint64 currentTimeout = (uint64)Min((retransmitTimeout * retransmitMultiplier), kMaxRetransmitDelay); + const uint64 currentTime = Platform::GetCurrentTimeInMs(); + + uint8 count = 0; + + // for every unacknowledged packet + for (Sequence seq = m_sendWindow.nextUnacknowledgedSequence; + seq <= m_sendWindow.lastSentSequence; + seq++) + { + const Sequence index = seq % m_sendWindow.GetWindowSize(); + const uint64 currentDifference = (currentTime - m_sendWindow.initialTransmitTimeInMs[index]); + + // if it hasn't timed out yet we abort + if (currentDifference <= currentTimeout) + { + break; + } + + DD_ASSERT(m_sendWindow.valid[index] == true); + DD_ASSERT(m_sendWindow.sequence[index] == seq); + + m_sendWindow.messages[index].header.windowSize = m_receiveWindow.currentAvailableSize; + + // if we couldn't retransmit the message we abort + if (!SendOrClose(m_sendWindow.messages[index])) + { + break; + } + count++; + DD_PRINT(LogLevel::Debug, "RETRANSMIT: rtt: %0.2f retransmit timeout: %llu diff: %llu", m_sendWindow.roundTripTime, currentTimeout, currentDifference); + DD_PRINT(LogLevel::Debug, "RETRANSMIT: session %u seq %u count %u", m_sessionId, seq, m_sendWindow.retransmitCount); + } + + // if we successfully retransmitted any packets we increment the retrans count + if (count > 0) + { + DD_PRINT(LogLevel::Debug, "RETRANSMIT: retransmitted %u packets", count); + m_sendWindow.retransmitCount += 1; + } + } + else + { + Shutdown(Result::NotReady); + } + } + + // proceed to transmit any data we haven't sent yet + const WindowSize& windowSize = m_sendWindow.GetWindowSize(); + + Sequence seq = m_sendWindow.lastSentSequence + 1; + while ((seq < m_sendWindow.nextSequence) & (m_sendWindow.lastAvailableSize > 0)) + { + const uint32 index = seq % windowSize; + if (m_sendWindow.valid[index] & (seq == m_sendWindow.sequence[index])) + { + MessageBuffer& messageBuffer = m_sendWindow.messages[index]; + messageBuffer.header.windowSize = m_receiveWindow.currentAvailableSize; + + const Result sendResult = m_pMsgChannel->Forward(messageBuffer); + if (sendResult == Result::Success) + { + const uint64 currentTime = Platform::GetCurrentTimeInMs(); + m_sendWindow.initialTransmitTimeInMs[index] = currentTime; + m_sendWindow.lastSentSequence = messageBuffer.header.sequence; + m_sendWindow.lastAvailableSize -= 1; + } + else + { + if (sendResult != Result::NotReady) + { + Shutdown(Result::Error); + } + // packet dropped, abort transmitting + break; + } + seq++; + } + else + { + DD_ASSERT_REASON("Transmit window data corruption detected"); + } + } + } + + void Session::UpdateTimeout() + { + if (m_sessionState == SessionState::FinWait1) + { + if (WriteMessageIntoSendWindow(SessionMessage::Fin, 0, nullptr, kInfiniteTimeout) == Result::Success) + { + SetState(SessionState::FinWait2); + } + } + + if (m_sessionState == SessionState::FinWait2 && IsSendWindowEmpty()) + { + SetState(SessionState::Closed); + } + + if (m_sessionState == SessionState::Closing) + { + LockGuard lock(m_receiveWindow.lock); + + // if the only message we have left is the fin message, we are safe to transition to closed + if (m_receiveWindow.nextUnreadSequence < m_receiveWindow.nextExpectedSequence) + { + const Sequence index = m_receiveWindow.nextUnreadSequence % m_receiveWindow.GetWindowSize(); + MessageBuffer& message = m_receiveWindow.messages[index]; + if (static_cast(message.header.messageId) == SessionMessage::Fin) + { + SetState(SessionState::Closed); + } + } + } + } + + Result Session::Send(uint32 payloadSizeInBytes, const void* pPayload, uint32 timeoutInMs) + { + Result result = Result::Error; + if (m_sessionState != SessionState::Closed) + { + result = WriteMessageIntoSendWindow(SessionMessage::Data, payloadSizeInBytes, pPayload, timeoutInMs); + } + return result; + } + + Result Session::Receive(uint32 payloadSizeInBytes, void* pPayload, uint32* pBytesReceived, uint32 timeoutInMs) + { + Result result = Result::Error; + + if (m_sessionState >= SessionState::Established) + { + // Messages cannot be received after a session has entered the closing state. + result = m_receiveWindow.semaphore.Wait(timeoutInMs); + + if (result == Result::Success) + { + LockGuard lock(m_receiveWindow.lock); + DD_ASSERT(m_receiveWindow.nextUnreadSequence < m_receiveWindow.nextExpectedSequence); + + const Sequence index = m_receiveWindow.nextUnreadSequence % m_receiveWindow.GetWindowSize(); + MessageBuffer& message = m_receiveWindow.messages[index]; + + if (payloadSizeInBytes >= message.header.payloadSize) + { + if (static_cast(message.header.messageId) == SessionMessage::Data) + { + uint32 payloadSize = Platform::Min(message.header.payloadSize, payloadSizeInBytes); + + DD_PRINT(LogLevel::Never, "Reading message number %u", m_receiveWindow.nextUnreadSequence); + DD_ASSERT(m_receiveWindow.valid[index] && m_receiveWindow.sequence[index] == m_receiveWindow.nextUnreadSequence); + memcpy(pPayload, &message.payload[0], payloadSize); + *pBytesReceived = payloadSize; + } + else + { + DD_ASSERT(static_cast(message.header.messageId) == SessionMessage::Fin); + DD_ASSERT(m_sessionState == SessionState::Closing); + SetState(SessionState::Closed); + result = Result::EndOfStream; + } + m_receiveWindow.valid[index] = false; + m_receiveWindow.nextUnreadSequence++; + m_receiveWindow.currentAvailableSize = CalculateCurrentWindowSize(); + } + else + { + // Re-signal the semaphore so a future read can read it. + m_receiveWindow.semaphore.Signal(); + result = Result::InsufficientMemory; + } + } + } + return result; + } + + void Session::Shutdown(Result reason) + { + m_sessionTerminationReason = reason; + + switch (m_sessionState) + { + case SessionState::Closed: + case SessionState::FinWait1: + case SessionState::FinWait2: + case SessionState::Closing: + if (reason != Result::Success) + { + SetState(SessionState::Closed); + } + break; + case SessionState::Established: + if (reason == Result::Success) + { + // Send the request. + SetState(SessionState::FinWait1); + } else + { + SetState(SessionState::Closed); + } + break; + default: + SetState(SessionState::Closed); + break; + } + } + + void Session::Close(Result reason) + { + Orphan(); + Shutdown(reason); + } + + void Session::Orphan() + { + // WARNING - this can leak memory as this will lead to SessionTerminate not being called + DD_ASSERT(m_pSessionUserdata == nullptr); + m_pProtocolOwner = nullptr; + m_pSessionUserdata = nullptr; + } + + inline void DevDriver::Session::SetState(SessionState newState) + { + if (m_sessionState != newState) + { +#if defined(DEVDRIVER_SHOW_SYMBOLS) + DD_PRINT(LogLevel::Debug, "[Session] Session %u transitioned states: %s -> %s", + GetSessionId(), kStateName[static_cast(m_sessionState)], + kStateName[static_cast(newState)]); +#endif + m_sessionState = newState; + } + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/session.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/session.h new file mode 100644 index 000000000..4ff4084fd --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/session.h @@ -0,0 +1,299 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file session.h +* @brief Class declaration for session +*********************************************************************************************************************** +*/ + +#pragma once + +#include "gpuopen.h" +#include "ddPlatform.h" +#include "util/sharedptr.h" +#include "protocols/systemProtocols.h" +#include "protocolSession.h" +#include "protocolClient.h" +#include "protocolServer.h" + +namespace DevDriver +{ + class IMsgChannel; + + enum struct SessionState + { + Closed = 0, + Listening, + SynSent, + SynReceived, + Established, + FinWait1, + Closing, + FinWait2, + Count + }; + + DD_STATIC_CONST WindowSize kDefaultWindowSize = 128; + DD_STATIC_CONST float kInitialRoundTripTimeInMs = 50.0f; + + class Session : public ISession + { + public: + /// + /// Internal interface for SessionManager + /// + Session(IMsgChannel* pMsgChannel); + + Result Connect(IProtocolClient& owner, + ClientId remoteClientId, + SessionId sessionId); + + Result BindToServer(IProtocolServer& owner, + ClientId remoteClientId, + SessionProtocol::SessionVersion sessionVersion, + Version protocolVersion, + SessionId sessionId); + + void HandleMessage(SharedPointer& pSession, const MessageBuffer& messageBuffer); + + SessionState GetSessionState() const + { + return m_sessionState; + } + + void CloseIfOwnedBy(SharedPointer& pSession, IProtocolSession* pOwner) + { + if (pOwner == m_pProtocolOwner) + { + if (m_pProtocolOwner != nullptr) + { + m_pProtocolOwner->SessionTerminated(pSession, Result::EndOfStream); + Orphan(); + } + Shutdown(Result::Success); + } + } + + bool IsSessionOpenAndMatches(ClientId remoteClientId, SessionId sessionId) + { + return ((m_sessionId == sessionId) & + (m_remoteClientId == remoteClientId) & + (m_sessionState != SessionState::Closed)); + } + + void Update(const SharedPointer& pSession) + { + DD_ASSERT(pSession.Get() == this); + + UpdateReceiveWindow(); + UpdateSendWindow(); + UpdateTimeout(); + + // Update active sessions for non-clients + if (m_sessionState >= SessionState::Established) + { + if (m_pProtocolOwner != nullptr) + { + m_pProtocolOwner->UpdateSession(pSession); + } + else + { + Shutdown(Result::Error); + } + } + + if (m_sessionState == SessionState::Closed) + { + DD_PRINT(LogLevel::Debug, "[Session] Session %u terminated - reason %u", m_sessionId, m_sessionTerminationReason); + + if (m_pProtocolOwner != nullptr) + { + m_pProtocolOwner->SessionTerminated(pSession, m_sessionTerminationReason); + Orphan(); + } + } + } + + /// + /// Public ISession interface implementation + /// + + Result Send(uint32 payloadSizeInBytes, const void* pPayload, uint32 timeoutInMs) override final; + Result Receive(uint32 payloadSizeInBytes, void* pPayload, uint32* pBytesReceived, uint32 timeoutInMs) override final; + void Shutdown(Result reason) override final; + void Close(Result reason) override final; + +#if !DD_VERSION_SUPPORTS(GPUOPEN_SESSION_INTERFACE_CLEANUP_VERSION) + void OrphanSession() override final + { + Orphan(); + }; + + void CloseSession(Result reason = Result::Error) override final + { + Shutdown(reason); + }; +#endif + + void* SetUserData(void* pUserData) override final + { + return Platform::Exchange(m_pSessionUserdata, pUserData); + } + + void *GetUserData() const override final + { + return m_pSessionUserdata; + } + + SessionId GetSessionId() const override final + { + return m_sessionId; + } + + ClientId GetDestinationClientId() const override final + { + return m_remoteClientId; + } + + Version GetVersion() const override final + { + return m_protocolVersion; + } + + private: + Result MarkMessagesAsAcknowledged(Sequence maxSequenceNumber); + Result WriteMessageIntoReceiveWindow(const MessageBuffer& messageBuffer); + Result WriteMessageIntoSendWindow(SessionProtocol::SessionMessage message, uint32 payloadSizeInBytes, const void* pPayload, uint32 timeoutInMs); + + bool SendOrClose(const MessageBuffer& messageBuffer); + bool SendControlMessage(SessionProtocol::SessionMessage command, Sequence sequenceNumber); + bool SendAckMessage(); + + void HandleSynMessage(const MessageBuffer& messageBuffer); + void HandleSynAckMessage(const MessageBuffer& messageBuffer); + void HandleFinMessage(const MessageBuffer& messageBuffer); + void HandleDataMessage(const MessageBuffer& messageBuffer); + void HandleAckMessage(const MessageBuffer& messageBuffer); + void HandleRstMessage(const MessageBuffer& messageBuffer); + + void UpdateReceiveWindow(); + void UpdateSendWindow(); + void UpdateTimeout(); + + WindowSize CalculateCurrentWindowSize(); + bool IsSendWindowEmpty(); + void UpdateSendWindowSize(const MessageBuffer& messageBuffer); + + void Orphan(); + + inline void SetState(SessionState newState); + + template + struct TransmitWindow + { + MessageBuffer messages[size]; + Sequence sequence[size]; + uint64 initialTransmitTimeInMs[size]; + volatile bool valid[size]; + + Platform::AtomicLock lock; + Platform::Semaphore semaphore; + + Sequence nextSequence; + Sequence nextUnacknowledgedSequence; + Sequence lastSentSequence; + uint32 lastAckCount; + float roundTripTime; + uint8 retransmitCount; + + WindowSize lastAvailableSize; + + constexpr WindowSize GetWindowSize() const { return size; }; + + TransmitWindow() : + messages(), + sequence(), + initialTransmitTimeInMs(), + valid(), + lock(), + semaphore(size, size), + nextSequence(1), + nextUnacknowledgedSequence(1), + lastSentSequence(0), + lastAckCount(), + roundTripTime(kInitialRoundTripTimeInMs), + retransmitCount(0), + lastAvailableSize(1) + { + + }; + }; + + template + struct ReceiveWindow + { + MessageBuffer messages[size]; + Sequence sequence[size]; + volatile bool valid[size]; + + Platform::AtomicLock lock; + Platform::Semaphore semaphore; + + Sequence nextUnreadSequence; + Sequence nextExpectedSequence; + Sequence lastUnacknowledgedSequence; + WindowSize currentAvailableSize; + + constexpr WindowSize MaxAdvertizedSize() const { return size - (size >> 1); }; + constexpr WindowSize GetWindowSize() const { return size; }; + + ReceiveWindow() : + messages(), + sequence(), + valid(), + lock(), + semaphore(0, size), + nextUnreadSequence(1), + nextExpectedSequence(1), + lastUnacknowledgedSequence(1), + currentAvailableSize(size - (size >> 1)) + { + } + }; + + TransmitWindow m_sendWindow; + ReceiveWindow m_receiveWindow; + IMsgChannel* const m_pMsgChannel; + IProtocolSession* m_pProtocolOwner; + void* m_pSessionUserdata; + const ClientId m_clientId; + ClientId m_remoteClientId; + SessionId m_sessionId; + SessionState m_sessionState; + Result m_sessionTerminationReason; + Version m_protocolVersion; + SessionProtocol::SessionVersion m_sessionVersion; + }; +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/sessionManager.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/sessionManager.cpp new file mode 100644 index 000000000..4153842ad --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/sessionManager.cpp @@ -0,0 +1,466 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file sessionManager.cpp +* @brief Class definition for SessionManager component +*********************************************************************************************************************** +*/ + +#include "sessionManager.h" +#include "session.h" +#include "msgChannel.h" +#include "protocolServer.h" +#include "protocolClient.h" +#include +#include + +#if !defined(NDEBUG) && !defined(DEVDRIVER_SHOW_SYMBOLS) +#define DEVDRIVER_SHOW_SYMBOLS +#endif + +using namespace DevDriver::SessionProtocol; +using namespace DevDriver::Platform; + +namespace DevDriver +{ +#if defined(DEVDRIVER_SHOW_SYMBOLS) + static_assert(static_cast(SessionMessage::Unknown) == 0, "Unexpected SessionMessage::Unknown value."); + static_assert(static_cast(SessionMessage::Syn) == 1, "Unexpected SessionMessage::Syn value."); + static_assert(static_cast(SessionMessage::SynAck) == 2, "Unexpected SessionMessage::SynAck value."); + static_assert(static_cast(SessionMessage::Fin) == 3, "Unexpected SessionMessage::Fin value."); + static_assert(static_cast(SessionMessage::Data) == 4, "Unexpected SessionMessage::Data value."); + static_assert(static_cast(SessionMessage::Ack) == 5, "Unexpected SessionMessage::Ack value."); + static_assert(static_cast(SessionMessage::Rst) == 6, "Unexpected SessionMessage::Rst value."); + static_assert(static_cast(SessionMessage::Count) == 7, "Unexpected SessionMessage::Count value."); +/* + DD_STATIC_CONST const char* kMessageNames[static_cast(SessionMessage::Count)] = + { + "Unknown", + "Syn", + "SynAck", + "Fin", + "Data", + "Ack", + "Rst", + }; +*/ +#endif + + // We break the SessionId value into two, 16 bit values. These variables make it easier to operate on the bitfield + DD_STATIC_CONST uint32 kClientSessionIdSize = 16; + DD_STATIC_CONST uint32 kClientSessionIdMask = (1 << kClientSessionIdSize) - 1; + + // SendReset + // + // Sends a reset packet to the specified destination + inline Result SessionManager::SendReset( + ClientId remoteClientId, + uint32 remoteSessionId, + Result reason, + Version version) + { + return SendCommand(remoteClientId, + static_cast(SessionMessage::Rst), + remoteSessionId, + static_cast(reason), + version); + } + + // GetProtocolServer + // + // Synchronizes the SessionManager and retrieves the specified protocol server + IProtocolServer* SessionManager::GetProtocolServer(Protocol protocol) + { + // Look up the protocol in the hash map + Platform::LockGuard serverLock(m_serverMutex); + return m_protocolServers.FindPointer(protocol); + } + + // HasProtocolServer + // + // Synchronizes the SessionManager and checks for the presence of the specified protocol server + bool SessionManager::HasProtocolServer(Protocol protocol) + { + // Look up the protocol in the hash map + Platform::LockGuard serverLock(m_serverMutex); + return m_protocolServers.Contains(protocol); + } + + SessionManager::SessionManager(const AllocCb& allocCb) + : m_clientId(kBroadcastClientId) + , m_pMessageChannel(nullptr) + , m_lastSessionId(kInvalidSessionId) + , m_sessionMutex() + , m_sessions(allocCb) + , m_serverMutex() + , m_protocolServers(allocCb) + , m_active(false) + , m_allocCb(allocCb) + { + } + + SessionManager::~SessionManager() + { + Destroy(); + } + + // Init + // + // Initializes the SessionManager object and binds it to the message channel specified by pMessageChannel + Result SessionManager::Init(IMsgChannel* pMessageChannel) + { + Result result = Result::Error; + if (m_active == false) + { + DD_ASSERT(pMessageChannel != nullptr); + + m_pMessageChannel = pMessageChannel; + m_clientId = m_pMessageChannel->GetClientId(); + m_active = true; + + // Generate a random initial SessionId to help minimize probability of collision + Platform::Random rng; + m_lastSessionId = rng.Generate(); + result = Result::Success; + } + return result; + } + + // Destroy + // + // Destroys the session manager object + Result SessionManager::Destroy() + { + if (m_active) + { + m_active = false; + + // Close all active sessions. + m_sessionMutex.Lock(); + for (auto& pair : m_sessions) + { + auto& pSession = pair.value; + DD_ASSERT(pSession.IsNull() == false); + pSession->Shutdown(Result::Success); + } + + m_sessionMutex.Unlock(); + + // Wait for sessions to close. + while (m_sessions.Size() > 0) + { + m_pMessageChannel->Update(); + } + } + return Result::Success; + } + + Result SessionManager::EstablishSessionForClient(IProtocolClient& protocolClient, + ClientId dstClientId) + { + Result result = Result::Error; + + SharedPointer pSession = + SharedPointer::Create(m_allocCb, + m_pMessageChannel); + if (!pSession.IsNull()) + { + // Create a new sessionRef. + // Get a new sessionRef id for the sessionRef. + Platform::LockGuard sessionLock(m_sessionMutex); + + const SessionId sessionId = GetNewSessionId(kInvalidSessionId); + + result = pSession->Connect(protocolClient, + dstClientId, + sessionId); + if (result == Result::Success) + { + result = m_sessions.Create(sessionId, pSession); + } + } + return result; + } + + Result SessionManager::RegisterProtocolServer(IProtocolServer* pServer) + { + // Make sure we're passed a valid server + DD_ASSERT(pServer != nullptr); + Platform::LockGuard serverLock(m_serverMutex); + return m_protocolServers.Create(pServer->GetProtocol(), pServer); + } + + Result SessionManager::UnregisterProtocolServer(IProtocolServer* pServer) + { + // Make sure we're passed a valid server + DD_ASSERT(pServer != nullptr); + + Result result = Result::Error; + + Platform::LockGuard serverLock(m_serverMutex); + Platform::LockGuard sessionLock(m_sessionMutex); + + const Protocol protocol = pServer->GetProtocol(); + IProtocolServer* pFoundServer = m_protocolServers.FindPointer(protocol); + + // Make sure we were previously registered. + if ((pFoundServer != nullptr) && (pFoundServer == pServer)) + { + for (auto& pair : m_sessions) + { + auto& pSession = pair.value; + // WARNING - this can cause sessionRef data to leak. + // We need a better way to clean up active sessions for protocol servers + DD_ASSERT(pSession.IsNull() == false); + pSession->CloseIfOwnedBy(pSession, pServer); + } + result = m_protocolServers.Erase(protocol); + } + else + { + DD_ALERT_REASON("Attempted to unregister an unknown protocol server"); + } + return result; + } + + ////////////////////////////////////////////////////////////////////////////// + // + // Session protocol state management functions + // + + // Lookup sessionRef for sessionRef ID, only returning a sessionRef if the sessionRef has not already been closed. + SharedPointer SessionManager::FindOpenSession(SessionId sessionId) + { + Platform::LockGuard sessionLock(m_sessionMutex); + const auto sessionIter = m_sessions.Find(sessionId); + if (sessionIter != m_sessions.End()) + { + auto& pSession = sessionIter->value; + DD_ASSERT(pSession.IsNull() == false); + DD_ASSERT(pSession->GetSessionId() == sessionId); + if (pSession->GetSessionState() != SessionState::Closed) + { + return pSession; + } + } + return SharedPointer(); + } + + void SessionManager::HandleClientDisconnection(ClientId dstClientId) + { + Platform::LockGuard sessionLock(m_sessionMutex); + for (auto& pair : m_sessions) + { + auto& pSession = pair.value; + DD_ASSERT(pSession.IsNull() == false); + + if (pSession->GetDestinationClientId() == dstClientId) + { + pSession->Shutdown(Result::NotReady); + } + } + } + + void SessionManager::HandleReceivedSessionMessage(const MessageBuffer& messageBuffer) + { + DD_ASSERT(messageBuffer.header.protocolId == Protocol::Session); + DD_ASSERT(messageBuffer.header.dstClientId == m_clientId); + + const SessionId& remoteSessionId = messageBuffer.header.sessionId; + const ClientId& sourceClientId = messageBuffer.header.srcClientId; + + SharedPointer pSession = SharedPointer(); + Result reason = Result::Unavailable; + Version version = 0; + + switch (static_cast(messageBuffer.header.messageId)) + { + case SessionMessage::Syn: + { + const SynPayload* DD_RESTRICT pRequestPayload = + reinterpret_cast(&messageBuffer.payload[0]); + + // Look up the protocol in the hash map + Platform::LockGuard serverLock(m_serverMutex); + IProtocolServer* pServer = m_protocolServers.FindPointer(pRequestPayload->protocol); + + // If we have a protocol server registered for the requested protocol and we are accepting new + // connections + if (m_active && (pServer != nullptr)) + { + reason = Result::VersionMismatch; + + // The first step in accepting a connection is checking to see if the version requested is + // supported by the protocol server. + + const Version& minVersion = pRequestPayload->minVersion; + + // If the Session protocol version is high enough to support ranged tests we use the max value + // as the maximum bound for our protocol version range. + Version maxVersion; + if (pRequestPayload->sessionVersion >= kSessionProtocolRangeVersion) + { + maxVersion = Platform::Max(pRequestPayload->maxVersion, minVersion); + } + // Otherwise we just use the minimum version as our range + else + { + maxVersion = minVersion; + } + + // We pass these version into the protocol server and store the resulting version. This version + // is automatically added into the Rst packet if there is a version mismatch. + if (pServer->GetSupportedVersion(minVersion, maxVersion, &version)) + { + reason = Result::Rejected; + + // Create a new session object + pSession = SharedPointer::Create(m_allocCb, m_pMessageChannel); + if (!pSession.IsNull()) + { + // Assuming we made it this far, generate a new session ID and bind the session to the + // protocol server + Platform::LockGuard sessionLock(m_sessionMutex); + SessionId sessionId = GetNewSessionId(remoteSessionId); + Result result = pSession->BindToServer(*pServer, + sourceClientId, + pRequestPayload->sessionVersion, + version, + sessionId); + if (result == Result::Success) + { + result = m_sessions.Create(sessionId, pSession); + } + + // If insertion failed or the server rejects the session we close it and clear the + // sessionRef pointer. + if ((result != Result::Success) || !pServer->AcceptSession(pSession)) + { + pSession->Close(Result::Rejected); + pSession.Clear(); + } + } + } + } + break; + } + case SessionMessage::SynAck: + { + if (m_active) + { + // Handle edge case where the Ack for the SynAck was lost. In this situation, we've already moved + // into the established state but they have not. We do this first because we assume the Ack has + // dropped, and it's likely that the sessionRef has already retransmitted the SynAck multiple times. + Platform::LockGuard sessionLock(m_sessionMutex); + auto sessionIter = m_sessions.Find(remoteSessionId); + + // If the lookup succeeded, set the sessionRef pointer to the correct sessionRef + if (sessionIter != m_sessions.End()) + { + pSession = sessionIter->value; + } + // Otherwise we treat it as the initial transition, and look up the initial sessionRef ID that is + // in the payload. + else + { + const SynAckPayload* DD_RESTRICT pPayload = + reinterpret_cast(&messageBuffer.payload[0]); + sessionIter = m_sessions.Find(pPayload->initialSessionId); + // If we found it, we need to initialize the sessionRef pointer, then remove the sessionRef + // from the hashmap and reinsert it under the final sessionRef id. If this insertion fails + // (most likely due to a collision) then we close the sessionRef and clear our pointer. + if (sessionIter != m_sessions.End()) + { + pSession = sessionIter->value; + m_sessions.Remove(sessionIter); + if (m_sessions.Create(remoteSessionId, pSession) != Result::Success) + { + pSession->Shutdown(Result::Error); + pSession.Clear(); + reason = Result::Error; + } + } + } + } + break; + } + case SessionMessage::Fin: + case SessionMessage::Data: + case SessionMessage::Ack: + case SessionMessage::Rst: + pSession = FindOpenSession(remoteSessionId); + break; + default: + break; + } + + // If the sessionRef pointer is non-null, we pass the message on to it. Otherwise we send a reset packet + // to inform the other side that the connection is invalid. + if (!pSession.IsNull()) + { + DD_ASSERT(pSession->GetDestinationClientId() == sourceClientId); + pSession->HandleMessage(pSession, messageBuffer); + } + else + { + SendReset(sourceClientId, remoteSessionId, reason, version); + } + } + + void SessionManager::UpdateSessions() + { + Platform::LockGuard sessionLock(m_sessionMutex); + + auto it = m_sessions.Begin(); + while (it != m_sessions.End()) + { + const SharedPointer& pSession = it->value; + Session& sessionRef = *pSession.Get(); + + DD_ASSERT(m_active || sessionRef.GetSessionState() != SessionState::Established); + sessionRef.Update(pSession); + + // Remove closing sessions. + if (sessionRef.GetSessionState() == SessionState::Closed) + { + it = m_sessions.Remove(it); + continue; + } + ++it; + } + } + + SessionId SessionManager::GetNewSessionId(SessionId remoteSessionId) + { + const SessionId remoteInput = (remoteSessionId << kClientSessionIdSize); + SessionId sessionId; + do + { + const uint32 nextId = AtomicIncrement(&m_lastSessionId); + sessionId = (nextId & kClientSessionIdMask) | remoteInput; + } while ((sessionId == kInvalidSessionId) || m_sessions.Contains(sessionId)); + return sessionId; + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/sessionManager.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/sessionManager.h new file mode 100644 index 000000000..f5a7d6d4d --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/sessionManager.h @@ -0,0 +1,131 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file sessionManager.h +* @brief Class declaration for SessionManager +*********************************************************************************************************************** +*/ + +#pragma once + +#include "gpuopen.h" +#include "msgChannel.h" +#include "protocolServer.h" +#include "protocolClient.h" +#include "session.h" +#include "util/vector.h" +#include "util/sharedptr.h" +#include "util/hashMap.h" + +namespace DevDriver +{ + class SessionManager + { + public: + // Constructor + explicit SessionManager(const AllocCb& allocCb); + + // Destructor + ~SessionManager(); + + // Initialize the session manager. + Result Init(IMsgChannel* pMessageChannel); + + // Destroy the session manager, closing all sessions in the process. + Result Destroy(); + + // Creates a session with the specified remote client, using the provided protocol client. + Result EstablishSessionForClient(IProtocolClient& protocolClient, ClientId dstClientId); + + // Process a session message. + void HandleReceivedSessionMessage(const MessageBuffer& messageBuffer); + + // Updates all active sessions. + void UpdateSessions(); + + // Registers the protocol server provided. + Result RegisterProtocolServer(IProtocolServer* pServer); + + // Unregisters the protocol server provided and closes all associated connections. + Result UnregisterProtocolServer(IProtocolServer* pServer); + + // Get the pointer to the protocol server associated with the provided protocol, or nullptr. + IProtocolServer* GetProtocolServer(Protocol protocol); + + // Returns true if the protocol associated with the provided protocol exists, false otherwise. + bool HasProtocolServer(Protocol protocol); + + // Notify the session manager that the destination client has disconnected. + void HandleClientDisconnection(ClientId dstClientId); + + // Returns the currently associated ClientId, or kBroadcastClientId if not connected. + ClientId GetClientId() const { return m_clientId; }; + private: + // Server hash map goes from Protocol -> IProtocolServer*, with 8 buckets + using ServerHashMap = HashMap; + // Session hash map goes from SessionId -> SharedPointer with a default of 16 buckets + using SessionHashMap = HashMap, 16>; + + // Convenience method to send a command packet (e.g., one with no payload) with the given parameters + Result SendCommand( + ClientId remoteClientId, + MessageCode command, + SessionId sessionId, + Sequence sequenceNumber, + WindowSize windowSize) + { + MessageBuffer messageBuffer = {}; + messageBuffer.header.dstClientId = remoteClientId; + messageBuffer.header.srcClientId = m_clientId; + messageBuffer.header.protocolId = Protocol::Session; + messageBuffer.header.messageId = command; + messageBuffer.header.sessionId = sessionId; + messageBuffer.header.sequence = sequenceNumber; + messageBuffer.header.payloadSize = 0; + messageBuffer.header.windowSize = windowSize; + return m_pMessageChannel->Forward(messageBuffer); + } + + // Convenience method to send a reset packet + Result SendReset(ClientId remoteClientId, uint32 remoteSessionId, Result reason, Version version); + + SessionId GetNewSessionId(SessionId remoteSessionId); + SharedPointer FindOpenSession(SessionId sessionId); + + ClientId m_clientId; // Client Id associated with the session manager. + IMsgChannel* m_pMessageChannel; // Message Channel object. + Platform::Atomic m_lastSessionId; // Counter used to generate unique session IDs. + Platform::Mutex m_sessionMutex; // Mutex to synchronize session object access. + SessionHashMap m_sessions; // Hash map containing currently active sessions. + + Platform::Mutex m_serverMutex; // Mutex to synchronize access to protocol servers. + ServerHashMap m_protocolServers; // Hash map containing protocol servers. + + bool m_active; // Flag used to indicate whether the client accepts or rejects + // new sessions. + AllocCb m_allocCb; // Allocator callbacks. + }; + +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/socketMsgTransport.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/socketMsgTransport.cpp new file mode 100644 index 000000000..92e230ba9 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/socketMsgTransport.cpp @@ -0,0 +1,299 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "socketMsgTransport.h" +#include "protocols/systemProtocols.h" +#include "ddPlatform.h" +#include + +using namespace DevDriver::ClientManagementProtocol; + +namespace DevDriver +{ + // Take a TransportType and find the associated SocketType for the current platform + inline static SocketType TransportToSocketType(TransportType type) + { + SocketType result = SocketType::Unknown; + switch (type) + { +#ifndef _WIN32 + case TransportType::Local: + result = SocketType::Local; + break; +#endif + case TransportType::Remote: + result = SocketType::Udp; + break; + default: + DD_ALERT_REASON("Invalid transport type specified"); + break; + } + return result; + } + + SocketMsgTransport::SocketMsgTransport(const HostInfo& hostInfo) : + m_connected(false), + m_hostInfo(hostInfo), + m_socketType(TransportToSocketType(hostInfo.type)) + { + if ((m_socketType != SocketType::Udp) && (m_socketType != SocketType::Local)) + { + DD_ASSERT_REASON("Unsupported socket type provided"); + } + } + + SocketMsgTransport::~SocketMsgTransport() + { + Disconnect(); + } + + Result SocketMsgTransport::Connect(ClientId* pClientId, uint32 timeoutInMs) + { + DD_UNUSED(timeoutInMs); + DD_UNUSED(pClientId); + + // Attempt to connect to the remote host. + Result result = Result::Error; + + if (!m_connected) + { + result = m_clientSocket.Init(true, m_socketType); + + if (result == Result::Success) + { + result = m_clientSocket.Bind(nullptr, 0); + } + + if (result == Result::Success) + { + result = m_clientSocket.Connect(m_hostInfo.hostname, m_hostInfo.port); + } + m_connected = (result == Result::Success); + } + return result; + } + + Result SocketMsgTransport::Disconnect() + { + Result result = Result::Error; + if (m_connected) + { + m_connected = false; + result = m_clientSocket.Close(); + } + return result; + } + +#if !DD_VERSION_SUPPORTS(GPUOPEN_DISTRIBUTED_STATUS_FLAGS_VERSION) + Result SocketMsgTransport::UpdateClientStatus(ClientId clientId, StatusFlags flags) + { + // not implemented + DD_UNUSED(clientId); + DD_UNUSED(flags); + return Result::Unavailable; + } +#endif + + Result SocketMsgTransport::ReadMessage(MessageBuffer &messageBuffer, uint32 timeoutInMs) + { + bool canRead = m_connected; + bool exceptState = false; + Result result = Result::Success; + + if (canRead & (timeoutInMs > 0)) + { + result = m_clientSocket.Select(&canRead, nullptr, &exceptState, timeoutInMs); + } + + if (result == Result::Success) + { + if (canRead) + { + size_t bytesReceived; + result = m_clientSocket.Receive(reinterpret_cast(&messageBuffer), sizeof(MessageBuffer), &bytesReceived); + } + else if (exceptState) + { + result = Result::Error; + } + else + { + result = Result::NotReady; + } + } + return result; + } + + Result SocketMsgTransport::WriteMessage(const MessageBuffer &messageBuffer) + { + DD_ASSERT(m_connected); + const size_t totalMsgSize = (sizeof(MessageHeader) + messageBuffer.header.payloadSize); + size_t bytesSent = 0; + return m_clientSocket.Send(reinterpret_cast(&messageBuffer), totalMsgSize, &bytesSent); + } + +#if !DD_VERSION_SUPPORTS(GPUOPEN_DISTRIBUTED_STATUS_FLAGS_VERSION) + Result SocketMsgTransport::QueryStatus(const HostInfo& hostInfo, + uint32 timeoutInMs, + StatusFlags* pFlags) + { + Result result = Result::Error; + Socket clientSocket; + const SocketType sType = TransportToSocketType(hostInfo.type); + + if (sType != SocketType::Unknown) + { + result = clientSocket.Init(true, sType); + + if (result == Result::Success) + { + result = clientSocket.Bind(nullptr, 0); + + if (result == Result::Success) + { + result = clientSocket.Connect(hostInfo.hostname, hostInfo.port); + } + + if (result == Result::Success) + { + MessageBuffer message = kOutOfBandMessage; + message.header.messageId = static_cast(ManagementMessage::QueryStatus); + + size_t bytesWritten = 0; + result = clientSocket.Send( + reinterpret_cast(&message), + sizeof(message.header), + &bytesWritten); + + if (result == Result::Success) + { + bool canRead = false; + bool exceptState = false; + result = clientSocket.Select(&canRead, nullptr, &exceptState, timeoutInMs); + if ((result == Result::Success) & (canRead) & (!exceptState)) + { + MessageBuffer responseMessage = {}; + size_t bytesReceived; + result = clientSocket.Receive(reinterpret_cast(&responseMessage), sizeof(MessageBuffer), &bytesReceived); + if (result == Result::Success) + { + result = Result::VersionMismatch; + if (IsOutOfBandMessage(responseMessage) & + IsValidOutOfBandMessage(responseMessage) & + (responseMessage.header.messageId == static_cast(ManagementMessage::QueryStatusResponse))) + { + const QueryStatusResponsePayload *pResponse = + reinterpret_cast(&responseMessage.payload[0]); + result = pResponse->result; + *pFlags = pResponse->flags; + } + } + } + } + } + clientSocket.Close(); + } + } + return result; + } +#endif + + // ================================================================================================================ + // Tests to see if the client can connect to RDS through this transport + Result SocketMsgTransport::TestConnection(const HostInfo& hostInfo, uint32 timeoutInMs) + { + Result result = Result::Error; + Socket clientSocket; + const SocketType sType = TransportToSocketType(hostInfo.type); + + if (sType != SocketType::Unknown) + { + result = clientSocket.Init(true, sType); + + if (result == Result::Success) + { + // Bind with no host info will bind our local side of the socket to a random port that is capable of + // receiving from any address. + result = clientSocket.Bind(nullptr, 0); + + // If we were able to bind to a socket we the connect to the remote host/port specified + if (result == Result::Success) + { + result = clientSocket.Connect(hostInfo.hostname, hostInfo.port); + } + + // If we made it this far we need to actually make sure we can actually communicate with the remote host + if (result == Result::Success) + { + // In order to test connectivity we are going to manually send a KeepAlive message. This message + // is discarded by both clients and RDS, making it safe to use for this purpose + MessageBuffer message = kOutOfBandMessage; + message.header.messageId = static_cast(ManagementMessage::KeepAlive); + + // Transmit the KeepAlive packet + size_t bytesWritten = 0; + result = clientSocket.Send( + reinterpret_cast(&message), + sizeof(message.header), + &bytesWritten); + + if (result == Result::Success) + { + // Wait until a response is waiting + bool canRead = false; + bool exceptState = false; + result = clientSocket.Select(&canRead, nullptr, &exceptState, timeoutInMs); + if ((result == Result::Success) & (canRead) & (!exceptState)) + { + // read the response + MessageBuffer responseMessage = {}; + size_t bytesReceived; + result = clientSocket.Receive(reinterpret_cast(&responseMessage), sizeof(MessageBuffer), &bytesReceived); + + // Check to make sure we got the response + that the response is the expected size + // KeepAlive is defined as having no additional payload, so it will only ever be the size of a header + if ((result == Result::Success) & (bytesReceived == sizeof(responseMessage.header))) + { + // Since we received a response, we know there is a server. An invalid packet here means that either + // the remote server didn't understand the request or that there was a logical bug on the server. + // In either case we treat this as a version mismatch since we can't tell the difference. + result = Result::VersionMismatch; + + // check packet validity and set success if true + if (IsOutOfBandMessage(responseMessage) & + IsValidOutOfBandMessage(responseMessage) & + (responseMessage.header.messageId == static_cast(ManagementMessage::KeepAlive))) + { + result = Result::Success; + } + } + } + } + } + clientSocket.Close(); + } + } + return result; + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/socketMsgTransport.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/socketMsgTransport.h new file mode 100644 index 000000000..43ae0accf --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/socketMsgTransport.h @@ -0,0 +1,97 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file socketMsgTransport.h +* @brief Class declaration for SocketMsgTransport +*********************************************************************************************************************** +*/ + +#pragma once + +#include "msgTransport.h" +#include "ddSocket.h" + +namespace DevDriver +{ + class SocketMsgTransport : public IMsgTransport + { + public: + explicit SocketMsgTransport(const HostInfo& hostInfo); + ~SocketMsgTransport(); + + Result Connect(ClientId* pClientId, uint32 timeoutInMs) override; + Result Disconnect() override; + + Result ReadMessage(MessageBuffer& messageBuffer, uint32 timeoutInMs) override; + Result WriteMessage(const MessageBuffer& messageBuffer) override; + + const char* GetTransportName() const override + { + const char *pName = "Unknown"; + switch (m_socketType) + { + case SocketType::Tcp: + pName = "TCP Socket"; + break; + case SocketType::Udp: + pName = "UDP Socket"; + break; + case SocketType::Local: +#if !defined(DD_WINDOWS) + pName = "Unix Domain Socket"; + break; +#endif + default: + break; + } + + return pName; + } + +#if !DD_VERSION_SUPPORTS(GPUOPEN_DISTRIBUTED_STATUS_FLAGS_VERSION) + Result UpdateClientStatus(ClientId clientId, StatusFlags flags) override; + static Result QueryStatus(const HostInfo& hostInfo, uint32 timeoutInMs, StatusFlags *pFlags); +#endif + + static Result TestConnection(const HostInfo& connectionInfo, uint32 timeoutInMs); + + DD_STATIC_CONST bool RequiresKeepAlive() + { + return true; + } + + DD_STATIC_CONST bool RequiresClientRegistration() + { + return true; + } + + private: + Socket m_clientSocket; + bool m_connected; + const HostInfo m_hostInfo; + const SocketType m_socketType; + }; + +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/win/d3d12EtwDxgkParser.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/win/d3d12EtwDxgkParser.h new file mode 100644 index 000000000..2fddfd38c --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/win/d3d12EtwDxgkParser.h @@ -0,0 +1,192 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +//============================================================================= +/// Copyright (c) 2016 Advanced Micro Devices, Inc. All rights reserved. +/// \author AMD Developer Tools Team +/// \file +/// \brief Implementation of a realtime D3D12 ETW Event consumer. +//============================================================================= + +#pragma once + +#include "gpuopen.h" +#include "ddPlatform.h" +#include "protocols/etwProtocol.h" +#include +#include +#include +#include +#include + +namespace DevDriver +{ + static const wchar_t* kDxgKernelProviderGuid = L"{802ec45a-1e99-4b83-9920-87c98277ba9d}"; ///< The DXGKernel ETW provider's GUID. + + namespace DxgkEtwParser + { + struct CommonQueueEvent + { + uint64 timestamp; + uint64 contextIdentifier; + uint32 sequence; + GpuEventType type; + }; + + class EventLess + { + public: + bool operator() (const CommonQueueEvent &left, const CommonQueueEvent&right) + { + return left.timestamp < right.timestamp; + } + }; + + struct FenceObject + { + uint64 fenceObject; + uint64 fenceValue; + }; + + struct QueueSyncSubmissionEvent : public CommonQueueEvent + { + std::vector fences; + }; + + struct QueueSyncCompletionEvent : public CommonQueueEvent + { + }; + + struct EventStorage + { + std::unordered_map> submissionEvents; + }; + +#pragma warning(push) + // enable MSVC specific extension that allows zero sized arrays in structs +#pragma warning(disable : 4200) +#pragma pack(push) +#pragma pack(1) + template + struct ArrayHeader + { + UINT32 count; + T values[]; + }; + + template + struct PointerSize + { + }; + + template<> + struct PointerSize + { + typedef ULONGLONG type; + }; + + template<> + struct PointerSize + { + typedef ULONG type; + }; + + template + using Pointer = typename PointerSize::type; + + enum struct CommandBufferType : UINT32 + { + Render = 0, + MmioFlip = 3, + Wait = 4, + Signal = 5, + Device = 6, + Software = 7, + Paging = 8, + }; + + template + struct QueueFenceHeader + { + Pointer hContext; + UINT32 sequence; + UINT32 flags; + }; + + template + struct WaitPacketHeader : QueueFenceHeader + { + Pointer hSyncObject; + UINT64 fenceValue; + }; + + template + struct SignalPacketHeader : QueueFenceHeader + { + ArrayHeader> semaphore; + }; + + template + struct SyncQueuePacketHeader + { + Pointer hContext; + CommandBufferType packetType; + UINT32 sequence; + }; + + // technically, the end packets have extra values after the common header. We don't actually use them though. + //struct EndQueuePacket : SyncQueuePacketHeader + //{ + // UINT32 preempted; + // UINT32 timeout; + //}; +#pragma pack(pop) +#pragma warning(pop) + } + + enum struct Event + { + Unknown, + QueuePacket, + }; + +#pragma warning(push) + // MSVC has a known issue where it triggers warnings for initializing static objects with literals. +#pragma warning(disable : 4592) + // we define a static object to force the compiler to handle string hashing for us. + // this should be const, but there are MSVC compiler bugs that prevent that. + static std::unordered_map kObjectTypeMap = { + { L"QueuePacket", Event::QueuePacket }, + }; +#pragma warning(pop) + + enum struct QueuePacketId : UINT32 + { + Unknown = 0, + Info = 0x00b3, + End = 0x00b4, + Wait = 0x00f4, + Signal = 0x00f5, + }; +} diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/win/d3d12EtwEventParser.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/win/d3d12EtwEventParser.h new file mode 100644 index 000000000..b2bcdfd35 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/win/d3d12EtwEventParser.h @@ -0,0 +1,330 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +//============================================================================= +/// Copyright (c) 2016 Advanced Micro Devices, Inc. All rights reserved. +/// \author AMD Developer Tools Team +/// \file +/// \brief Implementation of a realtime D3D12 ETW Event consumer. +//============================================================================= + +#pragma once + +#include "gpuopen.h" +#include "ddPlatform.h" +#include "protocols/etwProtocol.h" +#include "util/queue.h" +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "d3d12EtwDxgkParser.h" + +namespace DevDriver +{ + class GpuEventComparison + { + public: + bool operator() (const GpuEvent & lhs, const GpuEvent & rhs) + { + //your code... + return lhs.submissionTime < rhs.submissionTime; + } + typedef GpuEvent first_argument_type; + typedef GpuEvent second_argument_type; + typedef bool result_type; + }; + + using ParsedStorage = std::priority_queue, GpuEventComparison>; + + struct TraceStorage + { + ParsedStorage parsedEvents; + DxgkEtwParser::EventStorage dxgkEvents; + ProcessId processId; + }; + + template + void PrintPacketData(TraceStorage &traceData, PEVENT_RECORD pEvent) + { + const char* pBaseAddress = ((const char*)pEvent->UserData); + const uint32* pIteratorPointer = reinterpret_cast(pBaseAddress); + const uint32* pEndPointer = reinterpret_cast(pBaseAddress + pEvent->UserDataLength); + + while (pIteratorPointer < pEndPointer) + { + printf(" %.8X\n", *pIteratorPointer); + pIteratorPointer++; + } + printf("\n"); + } + + namespace DxgkEtwParser + { + + template + void ProcessWaitQueuePacket(TraceStorage &traceData, PEVENT_RECORD pEvent) + { + using WaitPacket = WaitPacketHeader; + + const char* pBaseAddress = ((const char*)pEvent->UserData); + const WaitPacket *pHeader = reinterpret_cast(pBaseAddress); + + // create event and copy raw time into it + QueueSyncSubmissionEvent event = {}; + event.type = GpuEventType::QueueWait; + + // TODO: Is this correct? Do we need to modify this at all? + event.timestamp = static_cast(pEvent->EventHeader.TimeStamp.QuadPart); + event.contextIdentifier = pHeader->hContext; + event.sequence = pHeader->sequence; + event.fences.emplace_back(FenceObject({ pHeader->hSyncObject, pHeader->fenceValue })); + + traceData.dxgkEvents.submissionEvents[event.contextIdentifier][event.sequence] = event; + } + + template + void ProcessSignalQueuePacket(TraceStorage &traceData, PEVENT_RECORD pEvent) + { + using SignalPacket = SignalPacketHeader; + const char* pBaseAddress = ((const char*)pEvent->UserData); + const SignalPacket *pHeader = reinterpret_cast(pBaseAddress); + // create event and copy raw time into it + QueueSyncSubmissionEvent event = {}; + event.type = GpuEventType::QueueSignal; + + // TODO: Is this correct? Do we need to modify this at all? + event.timestamp = static_cast(pEvent->EventHeader.TimeStamp.QuadPart); + event.contextIdentifier = pHeader->hContext; + event.sequence = pHeader->sequence; + + const uint64 *fenceValues = (const uint64*)(((const char*)&pHeader->semaphore.values[0]) + sizeof(uint64) * pHeader->semaphore.count); + for (UINT32 i = 0; i < pHeader->semaphore.count; i++) + { + event.fences.emplace_back(FenceObject({ pHeader->semaphore.values[i], fenceValues[i] })); + } + + traceData.dxgkEvents.submissionEvents[event.contextIdentifier][event.sequence] = event; + } + + template + void FinalizeSyncQueuePacket(TraceStorage &traceData, GpuEventType type, uint64 context, uint32 sequence, uint64 timestamp) + { + const auto &findContext = traceData.dxgkEvents.submissionEvents.find(context); + if (findContext != traceData.dxgkEvents.submissionEvents.end()) + { + const auto& find = findContext->second.find(sequence); + if (find != findContext->second.end()) + { + const QueueSyncSubmissionEvent &submissionEvent = find->second; + if (sequence == submissionEvent.sequence && type == submissionEvent.type) + { + GpuEvent event = {}; + event.type = type; + event.submissionTime = submissionEvent.timestamp; + event.completionTime = timestamp; + event.queue.contextIdentifier = submissionEvent.contextIdentifier; + for (auto &fence : submissionEvent.fences) + { + event.queue.fenceObject = fence.fenceObject; + event.queue.fenceValue = fence.fenceValue; + traceData.parsedEvents.emplace(event); + } + } + } + } + } + + template + void ProcessSyncEndQueuePacket(TraceStorage &traceData, PEVENT_RECORD pEvent) + { + using SyncQueuePacket = SyncQueuePacketHeader; + const SyncQueuePacket* pHeader = reinterpret_cast(pEvent->UserData); + switch (pHeader->packetType) + { + case CommandBufferType::Signal: + { + FinalizeSyncQueuePacket(traceData, + GpuEventType::QueueSignal, + pHeader->hContext, + pHeader->sequence, + static_cast(pEvent->EventHeader.TimeStamp.QuadPart)); + break; + } + case CommandBufferType::Wait: + { + FinalizeSyncQueuePacket(traceData, + GpuEventType::QueueWait, + pHeader->hContext, + pHeader->sequence, + static_cast(pEvent->EventHeader.TimeStamp.QuadPart)); + break; + } + default: + break; + } + } + + template + void ParseQueuePacket(TraceStorage &traceData, PEVENT_RECORD pEvent) + { + switch (static_cast(pEvent->EventHeader.EventDescriptor.Id)) + { + case QueuePacketId::End: + ProcessSyncEndQueuePacket(traceData, pEvent); + break; + case QueuePacketId::Signal: + if (pEvent->EventHeader.ProcessId == traceData.processId) + ProcessSignalQueuePacket(traceData, pEvent); + break; + case QueuePacketId::Wait: + if (pEvent->EventHeader.ProcessId == traceData.processId) + ProcessWaitQueuePacket(traceData, pEvent); + break; + default: + break; + } + } + + template + void ParsePacket(TraceStorage &traceData, PEVENT_RECORD pEvent) + { + char buffer[4096]; + PTRACE_EVENT_INFO pInfo = reinterpret_cast(&buffer[0]); + DWORD BufferSize = sizeof(buffer); + + // Retrieve the required buffer size for the event metadata. + DWORD result = TdhGetEventInformation(pEvent, 0, nullptr, pInfo, &BufferSize); + if (result == ERROR_SUCCESS) + { + LPWSTR eventString = (LPWSTR)((PBYTE)(pInfo)+pInfo->TaskNameOffset); + + std::wstring strName = std::wstring(eventString); + const Event type = kObjectTypeMap[strName]; + switch (type) + { + case Event::QueuePacket: + { + DxgkEtwParser::ParseQueuePacket(traceData, pEvent); + break; + } + default: + break; + } + } + } + } + + class EtwParser + { + public: + EtwParser() + : m_traceData() + , m_dxgKernelProviderGUID() + { + HRESULT result = CLSIDFromString(kDxgKernelProviderGuid, &m_dxgKernelProviderGUID); + (void)result; + } + + bool Start(ProcessId pid) + { + DD_ASSERT(m_traceData.processId == 0); + if (m_traceData.processId == 0) + { + m_traceData.processId = pid; + return true; + } + return false; + } + + void ParseEvent(PEVENT_RECORD pEvent) + { + bool is32Bit = (pEvent->EventHeader.Flags & EVENT_HEADER_FLAG_32_BIT_HEADER) != 0; + if (is32Bit) + { + ParseEventInternal(pEvent); + } + else + { + ParseEventInternal(pEvent); + } + } + + void ClearEvents() + { + + } + + size_t FinishTrace(Queue& msgQueue) + { + size_t result = 0; + if (m_traceData.processId != 0) + { + using namespace DevDriver::ETWProtocol; + + result = m_traceData.parsedEvents.size(); + + while (m_traceData.parsedEvents.size() > 0) + { + ETWPayload *pPayload = msgQueue.AllocateBack(); + if (pPayload != nullptr) + { + pPayload->command = ETWMessage::TraceDataChunk; + pPayload->traceDataChunk.numEvents = 0; + for (uint32 count = 0; count < kMaxEventsPerChunk && m_traceData.parsedEvents.size() > 0; count++) + { + pPayload->traceDataChunk.events[count] = m_traceData.parsedEvents.top(); + m_traceData.parsedEvents.pop(); + pPayload->traceDataChunk.numEvents++; + } + } + } + m_traceData.processId = 0; + } + return result; + } + private: + TraceStorage m_traceData; + GUID m_dxgKernelProviderGUID; + + template + void ParseEventInternal(PEVENT_RECORD pEvent) + { + int isDxgKernelProviderEvent = IsEqualGUID(pEvent->EventHeader.ProviderId, m_dxgKernelProviderGUID); + if (isDxgKernelProviderEvent != 0) + { + DxgkEtwParser::ParsePacket(m_traceData, pEvent); + } + } + }; +} diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/win/ddWinEtwServerSession.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/win/ddWinEtwServerSession.h new file mode 100644 index 000000000..182ade31c --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/win/ddWinEtwServerSession.h @@ -0,0 +1,305 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +//============================================================================= +/// Copyright (c) 2016 Advanced Micro Devices, Inc. All rights reserved. +/// \author AMD Developer Tools Team +/// \file +/// \brief Implementation of a realtime D3D12 ETW Event consumer. +//============================================================================= + +#pragma once + +#include "traceSession.h" +#include "gpuopen.h" +#include "protocols/etwProtocol.h" +#include + +#include "util/queue.h" +#include "../win/traceSession.h" +#include "../win/d3d12EtwEventParser.h" + +namespace DevDriver +{ + namespace ETWProtocol + { + enum class SessionState + { + Idle = 0, + Tracing, + Streaming, + TransmitMessage + }; + + class ETWSession : public ETWConsumerBase + { + public: + ETWSession(const SharedPointer& pSession, + const AllocCb& allocCb) : + m_pSession(pSession), + m_allocCb(allocCb), + m_state(SessionState::Idle), + m_payload(), + m_trace(allocCb), + m_numEvents(0), + m_traceSession(), + m_traceParser(), + m_traceInProgress(false) + { + }; + + ~ETWSession() { + if (m_traceInProgress != false) + { + m_traceSession.Stop(); + m_traceInProgress = false; + m_traceThread.join(); + m_trace.Clear(); + } + }; + + void UpdateSession() + { + DD_ASSERT(this == reinterpret_cast(m_pSession->GetUserData())); + + switch (m_state) + { + case SessionState::Idle: + { + ETWPayload payload; + uint32 bytesReceived = 0; + Result result = m_pSession->Receive(sizeof(payload), &payload, &bytesReceived, kNoWait); + if (result == Result::Success) + { + DD_ASSERT(sizeof(payload) == bytesReceived); + m_trace.Clear(); + m_numEvents = 0; + + if (payload.command == ETWMessage::BeginTrace) + { + DD_PRINT(LogLevel::Info, "[ETWSession] Trace request received"); + m_payload.command = ETWMessage::BeginResponse; + m_payload.startTraceResponse.result = BeginTrace(payload.startTrace.processId); + DD_ASSERT(m_payload.startTraceResponse.result == Result::Success); + TransmitAndChangeState(); + } + } + break; + } + case SessionState::TransmitMessage: + { + TransmitAndChangeState(); + break; + } + case SessionState::Tracing: + { + ETWPayload payload; + uint32 bytesReceived = 0; + Result result = m_pSession->Receive(sizeof(payload), &payload, &bytesReceived, kNoWait); + if (result == Result::Success) + { + DD_ASSERT(sizeof(payload) == bytesReceived); + if (payload.command == ETWMessage::EndTrace) + { + m_payload.command = ETWMessage::EndResponse; + m_payload.stopTraceResponse.result = EndTrace(); + + if (payload.stopTrace.discard == 0) + { + m_payload.stopTraceResponse.numEventsCaptured = static_cast(m_numEvents); + } + else + { + m_payload.stopTraceResponse.numEventsCaptured = 0; + m_trace.Clear(); + } + TransmitAndChangeState(); + } + } + break; + } + case SessionState::Streaming: + { + while (m_trace.Size() > 0) + { + ETWPayload *pPayload = m_trace.PeekFront(); + Result sendResult = m_pSession->Send(sizeof(ETWPayload), pPayload, kNoWait); + if (sendResult == Result::Success) + { + m_trace.PopFront(); + } + else if (sendResult == Result::NotReady) + { + break; + } + } + if ((m_trace.Size() == 0) & (m_numEvents > 0)) + { + m_payload.command = ETWMessage::TraceDataSentinel; + m_payload.traceDataSentinel.result = Result::Success; + TransmitAndChangeState(); + } + break; + } + default: + DD_UNREACHABLE(); + break; + } + } + + Result BeginTrace(ProcessId processId) + { + if (m_traceInProgress == false) + { + DD_PRINT(LogLevel::Info, "[ETWSession::BeginTrace] Beginning trace"); + + bool started = m_traceSession.Start(); + if (started) + { + DD_PRINT(LogLevel::Info, "[ETWSession::BeginTrace] Trace session started"); + + if (m_traceParser.Start(processId)) + { + DD_PRINT(LogLevel::Info, "[ETWSession::BeginTrace] Trace parser started for process %u", processId); + if (m_traceSession.Open(this)) + { + DD_PRINT(LogLevel::Info, "[ETWSession::BeginTrace] Trace session opened"); + //PCWSTR d3dRuntimeProviderGUID = L"{5d8087dd-3a9b-4f56-90df-49196cdc4f11}"; + PCWSTR dxgKernelProviderGUID = L"{802ec45a-1e99-4b83-9920-87c98277ba9d}"; + + //bool bRuntimeProviderEnabled = m_traceSession.EnableProviderByGUID(d3dRuntimeProviderGUID, 0); + //if (!bRuntimeProviderEnabled) + //{ + // wprintf(L"Failed to enable provider with GUID '%s'\n", d3dRuntimeProviderGUID); + //} + + bool bDxgKernelProviderEnabled = m_traceSession.EnableProviderByGUID(dxgKernelProviderGUID, 0); + if (bDxgKernelProviderEnabled) + { + DD_PRINT(LogLevel::Info, "[ETWSession::BeginTrace] DXGK provider enabled"); + m_traceThread = std::thread(&TraceSession::Process, &m_traceSession); + if (m_traceThread.joinable()) + { + DD_PRINT(LogLevel::Info, "[ETWSession::BeginTrace] Trace thread started"); + m_traceInProgress = true; + return Result::Success; + } + } + } + } + } + } + DD_PRINT(LogLevel::Info, "[ETWSession::BeginTrace] Begin failed"); + return Result::Error; + } + + Result EndTrace() + { + if (m_traceInProgress != false) + { + DD_PRINT(LogLevel::Info, "[ETWSession::EndTrace] Ending trace"); + if (m_traceSession.Close()) + { + DD_PRINT(LogLevel::Info, "[ETWSession::EndTrace] Trace session closed"); + if (m_traceSession.Stop()) + { + DD_PRINT(LogLevel::Info, "[ETWSession::EndTrace] Trace session stopped"); + m_traceInProgress = false; + m_traceThread.join(); + m_trace.Clear(); + m_numEvents = m_traceParser.FinishTrace(m_trace); + DD_PRINT(LogLevel::Info, "[ETWSession::EndTrace] Finished parsing %u events", m_numEvents); + return Result::Success; + } + } + } + DD_PRINT(LogLevel::Info, "[ETWSession::EndTrace] End failed"); + return Result::Error; + } + + void OnEventRecord(PEVENT_RECORD pEvent) override + { + m_traceParser.ParseEvent(pEvent); + } + + private: + SharedPointer m_pSession; + AllocCb m_allocCb; + SessionState m_state; + ETWPayload m_payload; + Queue m_trace; + size_t m_numEvents; + TraceSession m_traceSession; + std::thread m_traceThread; + EtwParser m_traceParser; + bool m_traceInProgress; + + void TransmitAndChangeState() + { + if (m_pSession->Send(sizeof(m_payload), &m_payload, kNoWait) == Result::Success) + { + switch (m_payload.command) + { + case ETWMessage::BeginResponse: + { + if (m_payload.startTraceResponse.result == Result::Success) + { + m_state = SessionState::Tracing; + } + else + { + m_state = SessionState::Idle; + } + break; + } + case ETWMessage::EndResponse: + { + if (m_payload.stopTraceResponse.result == Result::Success && + m_payload.stopTraceResponse.numEventsCaptured != 0) + { + m_state = SessionState::Streaming; + } + else + { + m_state = SessionState::Idle; + } + break; + } + case ETWMessage::TraceDataSentinel: + { + m_state = SessionState::Idle; + break; + } + default: + { + m_state = SessionState::Idle; + DD_UNREACHABLE(); + break; + } + } + } + } + }; + } +} diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/win/ddWinPipeMsgTransport.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/win/ddWinPipeMsgTransport.cpp new file mode 100644 index 000000000..e146ede97 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/win/ddWinPipeMsgTransport.cpp @@ -0,0 +1,343 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file ddWinPipeMsgTransport.cpp +* @brief Class declaration for WinPipeMsgTransport +*********************************************************************************************************************** +*/ + +#include "ddWinPipeMsgTransport.h" +#include "protocols/systemProtocols.h" +#include "ddPlatform.h" +#include + +using namespace DevDriver::ClientManagementProtocol; + +namespace DevDriver +{ + inline static Result GetLastConnectError() + { + Result result = Result::Error; + DWORD error = GetLastError(); + switch (error) + { + case ERROR_SEM_TIMEOUT: + result = Result::NotReady; + break; + case ERROR_FILE_NOT_FOUND: + result = Result::Unavailable; + break; + } + return result; + } + static Result WaitOverlapped(HANDLE hPipe, OVERLAPPED* pOverlapped, DWORD *pBytesTransferred, DWORD waitTimeMs) + { + DWORD waitResult = WAIT_OBJECT_0; + Result result = Result::NotReady; + + //BOOL result = GetOverlappedResultEx(hPipe, pOverlapped, pBytesTransferred, waitTimeMs, FALSE); + + if (waitTimeMs > 0) + waitResult = WaitForSingleObject(pOverlapped->hEvent, waitTimeMs); + + if (waitResult == WAIT_OBJECT_0) + { + if (GetOverlappedResult(hPipe, pOverlapped, pBytesTransferred, FALSE)) + result = Result::Success; + else + result = (GetLastError() == ERROR_IO_INCOMPLETE) ? Result::NotReady : Result::Error; + } + else if (waitResult != WAIT_TIMEOUT) + { + result = Result::Error; + } + return result; + } + + WinPipeMsgTransport::WinPipeMsgTransport(const HostInfo& hostInfo) : + m_hostInfo(hostInfo), + m_pipeHandle(INVALID_HANDLE_VALUE), + m_readTransaction(), + m_writeTransaction() + {} + + WinPipeMsgTransport::~WinPipeMsgTransport() + { + if (m_pipeHandle != INVALID_HANDLE_VALUE) + { + Disconnect(); + } + } + + Result WinPipeMsgTransport::Connect(ClientId* pClientId, uint32 timeoutInMs) + { + DD_UNUSED(pClientId); + DD_UNUSED(timeoutInMs); + + Result result = Result::Error; + + if (m_pipeHandle == INVALID_HANDLE_VALUE && WaitNamedPipe(m_hostInfo.hostname, timeoutInMs)) + { + m_pipeHandle = CreateFileA(m_hostInfo.hostname, // Pipe name + GENERIC_READ | GENERIC_WRITE, // Read and write access + 0, // No sharing + nullptr, // Default security attributes + OPEN_EXISTING, // Opens existing pipe + FILE_FLAG_OVERLAPPED, // Default attributes + nullptr); // No template file + + // CreateFile returns INVALID_HANDLE_VALUE on failure + if (m_pipeHandle != INVALID_HANDLE_VALUE) + { + DWORD dwMode = PIPE_READMODE_MESSAGE | PIPE_WAIT; + BOOL success = SetNamedPipeHandleState( + m_pipeHandle, // pipe handle + &dwMode, // new pipe mode + nullptr, // don't set maximum bytes + nullptr); // don't set maximum time + DD_ASSERT(success == TRUE); + if (success == TRUE) + { + m_readTransaction.oOverlap.Offset = 0; + m_readTransaction.oOverlap.OffsetHigh = 0; + m_readTransaction.oOverlap.hEvent = CreateEvent( + nullptr, // default security attribute + TRUE, // manual-reset event + FALSE, // initial state = unsignaled + nullptr); // unnamed event object + + m_writeTransaction.oOverlap.Offset = 0; + m_writeTransaction.oOverlap.OffsetHigh = 0; + m_writeTransaction.oOverlap.hEvent = CreateEvent( + nullptr, // default security attribute + TRUE, // manual-reset event + FALSE, // initial state = unsignaled + nullptr); // unnamed event object + + // CreateFile returns NULL on failure + DD_ASSERT((m_readTransaction.oOverlap.hEvent != NULL) & (m_writeTransaction.oOverlap.hEvent != NULL)); + + if ((m_readTransaction.oOverlap.hEvent != NULL) & (m_writeTransaction.oOverlap.hEvent != NULL)) + { + result = Result::Success; + } + } + } + else + { + result = GetLastConnectError(); + } + } + else + { + result = GetLastConnectError(); + } + return result; + } + + Result WinPipeMsgTransport::Disconnect() + { + Result result = Result::Error; + if (m_pipeHandle != INVALID_HANDLE_VALUE) + { + CancelIoEx(m_pipeHandle, &m_readTransaction.oOverlap); + CancelIoEx(m_pipeHandle, &m_writeTransaction.oOverlap); + CloseHandle(m_writeTransaction.oOverlap.hEvent); + CloseHandle(m_readTransaction.oOverlap.hEvent); + CloseHandle(m_pipeHandle); + m_writeTransaction.oOverlap.hEvent = 0; + m_readTransaction.oOverlap.hEvent = 0; + m_pipeHandle = INVALID_HANDLE_VALUE; + result = Result::Success; + } + return result; + } + +#if !DD_VERSION_SUPPORTS(GPUOPEN_DISTRIBUTED_STATUS_FLAGS_VERSION) + Result WinPipeMsgTransport::UpdateClientStatus(ClientId clientId, StatusFlags flags) + { + // not implemented + DD_UNUSED(clientId); + DD_UNUSED(flags); + return Result::Unavailable; + } +#endif + + Result WinPipeMsgTransport::ReadMessage(MessageBuffer &messageBuffer, uint32 timeoutInMs) + { + Result result = Result::Error; + DWORD receivedSize = 0; + + if (!m_readTransaction.ioPending) + { + + if (ReadFile(m_pipeHandle, &m_readTransaction.message, sizeof(MessageBuffer), &receivedSize, &m_readTransaction.oOverlap)) + { + result = Result::Success; + } + else if (GetLastError() == ERROR_IO_PENDING) + { + m_readTransaction.ioPending = true; + } + } + + if (m_readTransaction.ioPending) + { + result = WaitOverlapped(m_pipeHandle, &m_readTransaction.oOverlap, &receivedSize, timeoutInMs); + } + + if (result == Result::Success) + { + m_readTransaction.ioPending = false; + + memcpy(&messageBuffer, &m_readTransaction.message, receivedSize); + } + else if (result != Result::NotReady) + { + m_readTransaction.ioPending = false; + result = Result::Error; + } + + return result; + } + + Result WinPipeMsgTransport::WriteMessage(const MessageBuffer &messageBuffer) + { + Result result = Result::Error; + + //ResetEvent(m_writeTransaction.oOverlap.hEvent); + + const DWORD totalMsgSize = (sizeof(MessageHeader) + messageBuffer.header.payloadSize); + m_writeTransaction.cbSize = totalMsgSize; + DWORD bytesWritten = 0; + + BOOL fSuccess = WriteFile(m_pipeHandle, &messageBuffer, totalMsgSize, &bytesWritten, &m_writeTransaction.oOverlap); + + if (!fSuccess) + { + DWORD dwErr = GetLastError(); + if (dwErr == ERROR_IO_PENDING) + { + result = WaitOverlapped(m_pipeHandle, &m_writeTransaction.oOverlap, &bytesWritten, kInfiniteTimeout); + } + } + else + { + result = Result::Success; + } + + return result; + } + +#if !DD_VERSION_SUPPORTS(GPUOPEN_DISTRIBUTED_STATUS_FLAGS_VERSION) + Result WinPipeMsgTransport::QueryStatus(const HostInfo& hostInfo, + uint32 timeoutInMs, + StatusFlags* pFlags) + { + Result result = Result::Error; + + MessageBuffer message = kOutOfBandMessage; + message.header.messageId = static_cast(ManagementMessage::QueryStatus); + + MessageBuffer responseMessage = {}; + DWORD bytesRead = 0; + const BOOL success = CallNamedPipe(hostInfo.hostname, + &message, + sizeof(message.header), + &responseMessage, + sizeof(responseMessage), + &bytesRead, + timeoutInMs); + if ((success != FALSE) & (bytesRead > sizeof(responseMessage.header))) + { + result = Result::VersionMismatch; + if (IsOutOfBandMessage(responseMessage) & + IsValidOutOfBandMessage(responseMessage) & + (responseMessage.header.messageId == static_cast(ManagementMessage::QueryStatusResponse))) + { + QueryStatusResponsePayload *pResponse = + reinterpret_cast(&responseMessage.payload[0]); + result = pResponse->result; + *pFlags = pResponse->flags; + } + } + else + { + result = GetLastConnectError(); + } + + return result; + } +#endif + + // ================================================================================================================ + // Tests to see if the client can connect to RDS through this transport + Result WinPipeMsgTransport::TestConnection(const HostInfo& hostInfo, + uint32 timeoutInMs) + { + Result result = Result::Error; + + // In order to test connectivity we are going to manually send a KeepAlive message. This message is discarded + // by both clients and RDS, making it safe to use for this purpose + MessageBuffer message = kOutOfBandMessage; + message.header.messageId = static_cast(ManagementMessage::KeepAlive); + + MessageBuffer responseMessage = {}; + + // Use CallNamedPipe to connect, send, receive, and disconnect to the named pipe + DWORD bytesRead = 0; + const BOOL success = CallNamedPipe(hostInfo.hostname, + &message, + sizeof(message.header), + &responseMessage, + sizeof(responseMessage), + &bytesRead, + timeoutInMs); + // Check to make sure we got the response + that the response is the expected size + // KeepAlive is defined as having no additional payload, so it will only ever be the size of a header + if ((success != FALSE) & (bytesRead == sizeof(responseMessage.header))) + { + // Since we received a response, we know there is a server. An invalid packet here means that either + // the remote server didn't understand the request or that there was a logical bug on the server. + // In either case we treat this as a version mismatch since we can't tell the difference. + result = Result::VersionMismatch; + + // check packet validity and set success if true + if (IsOutOfBandMessage(responseMessage) & + IsValidOutOfBandMessage(responseMessage) & + (responseMessage.header.messageId == static_cast(ManagementMessage::KeepAlive))) + { + result = Result::Success; + } + } + else + { + // if the call failed, try to return a meaningful status result + result = GetLastConnectError(); + } + + return result; + } +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/win/ddWinPipeMsgTransport.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/win/ddWinPipeMsgTransport.h new file mode 100644 index 000000000..6049321cd --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/win/ddWinPipeMsgTransport.h @@ -0,0 +1,95 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file ddWinPipeMsgTransport.h +* @brief Class declaration for WinPipeMsgTransport +*********************************************************************************************************************** +*/ + +#pragma once + +#include "msgTransport.h" + +#ifndef WIN32_LEAN_AND_MEAN +#define WIN32_LEAN_AND_MEAN +#include +#include +#undef WIN32_LEAN_AND_MEAN +#else +#include +#include +#endif + +namespace DevDriver +{ + class WinPipeMsgTransport : public IMsgTransport + { + public: + explicit WinPipeMsgTransport(const HostInfo& hostInfo); + ~WinPipeMsgTransport(); + + Result Connect(ClientId* pClientId, uint32 timeoutInMs) override; + Result Disconnect() override; + + Result ReadMessage(MessageBuffer& messageBuffer, uint32 timeoutInMs) override; + Result WriteMessage(const MessageBuffer& messageBuffer) override; + + const char* GetTransportName() const override + { + return "Named Pipe"; + } + + DD_STATIC_CONST bool RequiresKeepAlive() + { + return false; + } + + DD_STATIC_CONST bool RequiresClientRegistration() + { + return true; + } + +#if !DD_VERSION_SUPPORTS(GPUOPEN_DISTRIBUTED_STATUS_FLAGS_VERSION) + Result UpdateClientStatus(ClientId clientId, StatusFlags flags) override; + static Result QueryStatus(const HostInfo& hostInfo, uint32 timeoutInMs, StatusFlags* pFlags); +#endif + static Result TestConnection(const HostInfo& hostInfo, uint32 timeoutInMs); + private: + HostInfo m_hostInfo; + HANDLE m_pipeHandle; + + struct PendingTransaction + { + OVERLAPPED oOverlap; + MessageBuffer message; + DWORD cbSize; + bool ioPending; + }; + + PendingTransaction m_readTransaction; + PendingTransaction m_writeTransaction; + }; + +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/win/ddWinPlatform.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/win/ddWinPlatform.cpp new file mode 100644 index 000000000..19db65799 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/win/ddWinPlatform.cpp @@ -0,0 +1,531 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ +/** +*********************************************************************************************************************** +* @file ddWinPlatform.cpp +* @brief User mode Windows platform layer implementation +*********************************************************************************************************************** +*/ + +#include "ddPlatform.h" + +//////////////////////////////// +// UMD + +#include + +#include +#include + +// Make sure our timeout definition matches the Windows value. +static_assert(DevDriver::kInfiniteTimeout == INFINITE, "Infinite Timeout value does not match OS definition!"); + +namespace DevDriver +{ + namespace Platform + { + inline Result WaitObject(HANDLE hObject, uint32 millisecTimeout) + { + DD_ASSERT(hObject != NULL); + DWORD status = WaitForSingleObject(hObject, millisecTimeout); + Result result = Result::Error; + switch (status) + { + case WAIT_OBJECT_0: + result = Result::Success; + break; + case WAIT_TIMEOUT: + result = Result::NotReady; + break; + } + DD_ALERT(result != Result::Error); + return result; + } + + //////////////////////// + // Open an event create in user space + // If hObject is not nullptr, the passed in handle is opened. + // If it is nullptr, we use the passed in name string. + inline HANDLE CopyHandleFromProcess(ProcessId processId, HANDLE hObject) + { + DD_ASSERT(hObject != NULL); + + HANDLE outputObject = nullptr; + + HANDLE hProcess = ::OpenProcess(PROCESS_ALL_ACCESS, TRUE /*bInheritHandle*/, static_cast(processId)); + + if (hProcess != nullptr) + { + // Just Duplicate the handle for UMD test + DuplicateHandle( + hProcess, + hObject, + GetCurrentProcess(), + &outputObject, + EVENT_ALL_ACCESS, + TRUE, /*Inherit Handle*/ + 0 /*options*/); + + CloseHandle(hProcess); + } + + DD_ALERT(outputObject != NULL); + return outputObject; + } + + ///////////////////////////////////////////////////// + // Local routines..... + // + void DebugPrint(LogLevel lvl, const char* format, ...) + { + DD_UNUSED(lvl); + + va_list args; + va_start(args, format); + char buffer[1024]; + vsnprintf_s(buffer, sizeof(buffer), _TRUNCATE, format, args); + va_end(args); + strcat_s(buffer, "\n"); + OutputDebugString(buffer); +#ifdef DEVDRIVER_PRINT_TO_CONSOLE + printf("%s", buffer); +#endif + } + + int32 AtomicIncrement(Atomic *variable) + { + return static_cast(InterlockedIncrementAcquire(variable)); + } + + int32 AtomicAdd(Atomic *variable, int32 num) + { + return static_cast(InterlockedAddAcquire(variable, static_cast(num))); + } + + int32 AtomicDecrement(Atomic *variable) + { + return static_cast(InterlockedDecrementAcquire(variable)); + } + + int32 AtomicSubtract(Atomic *variable, int32 num) + { + return static_cast(InterlockedAddAcquire(variable, -static_cast(num))); + } + + ///////////////////////////////////////////////////// + // Thread routines..... + // + + DWORD WINAPI PlatformThreadShim(void *pThreadParam) + { + DD_ASSERT(pThreadParam != nullptr); + const ThreadStorage *thread = reinterpret_cast(pThreadParam); + thread->callback(thread->parameter); + return 0; + } + + Thread::Thread() : m_thread() {}; + Thread::~Thread() {}; + + Result Thread::Start(void(*threadCallback)(void *), void *threadParameter) + { + Result result = Result::Error; + + if (m_thread.handle == NULL) + { + m_thread.parameter = threadParameter; + m_thread.callback = threadCallback; + + m_thread.handle = ::CreateThread( + nullptr, // Thread Attributes + 0, // Stack size (use default) + PlatformThreadShim, + &m_thread, + 0, // Creation flags - start immediately + nullptr); + + if (m_thread.handle != NULL) + { + result = Result::Success; + } + DD_ALERT(result != Result::Error); + } + return result; + }; + + Result Thread::Join() + { + DD_ASSERT(m_thread.handle != NULL); + Result result = WaitObject(m_thread.handle, kInfiniteTimeout); + if (result == Result::Success) + { + memset(&m_thread, 0, sizeof(ThreadStorage)); + } + DD_ALERT(result != Result::Error); + return result; + }; + + bool Thread::IsJoinable() const + { + return (m_thread.handle != NULL); + }; + + ///////////////////////////////////////////////////// + // Memory Management + ///////////////////////////////////////////////////// + + void* AllocateMemory(size_t size, size_t alignment, bool zero) + { + void* pMemory = _aligned_malloc(size, alignment); + if ((pMemory != nullptr) && zero) + { + memset(pMemory, 0, size); + } + + return pMemory; + } + + void FreeMemory(void* pMemory) + { + _aligned_free(pMemory); + } + + ///////////////////////////////////////////////////// + // Synchronization primatives... + // + + void AtomicLock::Lock() + { + Result result = Windows::AcquireFastLock(&m_lock); + DD_UNUSED(result); + DD_ASSERT(result == Result::Success); + + } + + void AtomicLock::Unlock() + { + Result result = Windows::ReleaseFastLock(&m_lock); + DD_UNUSED(result); + DD_ASSERT(result == Result::Success); + } + + Mutex::Mutex() + : m_mutex() + { + InitializeCriticalSection(&m_mutex.criticalSection); + } + + Mutex::~Mutex() + { +#if !defined(NDEBUG) + // This mutex was destroyed while locked. Potentially hazardous due to possibility of a pending wait on + // the lock + DD_ASSERT(m_mutex.lockCount == 0); +#endif + DeleteCriticalSection(&m_mutex.criticalSection); + } + + void Mutex::Lock() + { + EnterCriticalSection(&m_mutex.criticalSection); +#if !defined(NDEBUG) + const int32 count = AtomicIncrement(&m_mutex.lockCount); + // This lock was successfully locked twice. This indicates recursive lock usage, which is non supported + // on all platforms + DD_ASSERT(count == 1); + DD_UNUSED(count); +#endif + } + + void Mutex::Unlock() + { +#if !defined(NDEBUG) + AtomicDecrement(&m_mutex.lockCount); +#endif + LeaveCriticalSection(&m_mutex.criticalSection); + } + + Semaphore::Semaphore(uint32 initialCount, uint32 maxCount) + { + m_semaphore = Windows::CreateSharedSemaphore(initialCount, maxCount); + } + + Semaphore::~Semaphore() + { + Windows::CloseSharedSemaphore(m_semaphore); + } + + Result Semaphore::Signal() + { + return Windows::SignalSharedSemaphore(m_semaphore); + } + + Result Semaphore::Wait(uint32 millisecTimeout) + { + return WaitObject(reinterpret_cast(m_semaphore), millisecTimeout); + } + + Event::Event(bool signaled) + { + m_event = CreateEvent(nullptr, TRUE, static_cast(signaled), nullptr); + } + + Event::~Event() + { + CloseHandle(m_event); + } + + void Event::Clear() + { + ResetEvent(m_event); + } + + void Event::Signal() + { + SetEvent(m_event); + } + + Result Event::Wait(uint32 timeoutInMs) + { + return WaitObject(m_event,timeoutInMs); + } + + Random::Random() + { + } + + Random::~Random() + { + } + + uint32 Random::Generate() + { + uint32 value = 0; + errno_t result = rand_s(&value); + DD_ASSERT(result == 0); + DD_UNUSED(result); + return value; + } + + uint32 Random::Max() + { + return UINT_MAX; + } + + ProcessId GetProcessId() + { + return static_cast(GetCurrentProcessId()); + } + + uint64 GetCurrentTimeInMs() + { + return GetTickCount64(); + } + + void Sleep(uint32 millisecTimeout) + { + ::Sleep(millisecTimeout); + } + + void GetProcessName(char* buffer, size_t bufferSize) + { + char path[1024] = {}; + size_t numChars = 0; + + numChars = GetModuleFileNameExA(GetCurrentProcess(), nullptr, path, 1024); + + buffer[0] = 0; + if (numChars > 0) + { + char fname[256] = {}; + char ext[256] = {}; + _splitpath_s(path, nullptr, 0, nullptr, 0, fname, sizeof(fname), ext, sizeof(ext)); + strcat_s(buffer, bufferSize, fname); + strcat_s(buffer, bufferSize, ext); + } + } + + void Strncpy(char* pDst, const char* pSrc, size_t dstSize) + { + DD_ASSERT(pDst != nullptr); + DD_ASSERT(pSrc != nullptr); + DD_ALERT(strlen(pSrc) < dstSize); + + // Clamp the copy to the size of the dst buffer (1 char reserved for the null terminator). + strcpy_s(pDst, dstSize, pSrc); + } + + void Snprintf(char* pDst, size_t dstSize, const char* format, ...) + { + va_list args; + va_start(args, format); + vsnprintf_s(pDst, dstSize, _TRUNCATE, format, args); + va_end(args); + } + + void Vsnprintf(char* pDst, size_t dstSize, const char* format, va_list args) + { + vsnprintf_s(pDst, dstSize, _TRUNCATE, format, args); + } + + namespace Windows + { + // Windows specific functions required for in-memory communication + Result AcquireFastLock(Atomic *mutex) + { + // TODO - implement timeout + while (InterlockedCompareExchangeAcquire(mutex, 1, 0) == 1) + { + // spin until the mutex is unlocked again + while (*mutex != 0) + { + } + } + return Result::Success; + } + + Result ReleaseFastLock(Atomic *mutex) + { + if (InterlockedCompareExchangeRelease(mutex, 0, 1) == 0) + { + // tried to unlock an already unlocked mutex + return Result::Error; + } + return Result::Success; + } + + ///////////////////////////////////////////////////// + // Local routines..... + // + + Handle CreateSharedSemaphore(uint32 initialCount, uint32 maxCount) + { + // Create original object in the current process + return DD_PTR_TO_HANDLE(CreateSemaphore( + nullptr, + initialCount, + maxCount, + nullptr /* Not Named*/)); + } + + Handle CopySemaphoreFromProcess(ProcessId processId, Handle hObject) + { + return DD_PTR_TO_HANDLE(CopyHandleFromProcess(processId, reinterpret_cast(hObject))); + } + + Result SignalSharedSemaphore(Handle pSemaphore) + { + DD_ASSERT(pSemaphore != NULL); + BOOL result = ReleaseSemaphore(reinterpret_cast(pSemaphore), 1, nullptr); + return (result != 0) ? Result::Success : Result::Error; + } + + Result WaitSharedSemaphore(Handle pSemaphore, uint32 millisecTimeout) + { + return WaitObject(reinterpret_cast(pSemaphore), millisecTimeout); + } + + void CloseSharedSemaphore(Handle pSemaphore) + { + if (pSemaphore != NULL) + { + CloseHandle(reinterpret_cast(pSemaphore)); + } + } + + Handle CreateSharedBuffer(Size bufferSizeInBytes) + { + HANDLE hSharedBuffer = + CreateFileMapping( + INVALID_HANDLE_VALUE, // use paging file + nullptr, // default security + PAGE_READWRITE, // read/write access + 0, // maximum object size (high-order DWORD) + bufferSizeInBytes, // maximum object size (low-order DWORD) + nullptr); // name of mapping object + + DD_ALERT(hSharedBuffer != nullptr); + return DD_PTR_TO_HANDLE(hSharedBuffer); + } + + Handle MapSystemBufferView(Handle hBuffer, Size bufferSizeInBytes) + { + DD_ASSERT(hBuffer != kNullPtr); + LPVOID pSharedBufferView = MapViewOfFile( + reinterpret_cast(hBuffer), + FILE_MAP_ALL_ACCESS, // read/write permission + 0, // File offset high dword + 0, // File offset low dword + bufferSizeInBytes); + DD_ALERT(pSharedBufferView != nullptr); + return DD_PTR_TO_HANDLE(pSharedBufferView); + } + + void UnmapBufferView(Handle hSharedBuffer, Handle hSharedBufferView) + { + DD_UNUSED(hSharedBuffer); + DD_ASSERT(hSharedBufferView != kNullPtr); + BOOL result = UnmapViewOfFile(reinterpret_cast(hSharedBufferView)); + DD_UNUSED(result); + DD_ALERT(result == TRUE); + } + + void CloseSharedBuffer(Handle hSharedBuffer) + { + if (hSharedBuffer != kNullPtr) + { + BOOL result = CloseHandle(reinterpret_cast(hSharedBuffer)); + DD_ALERT(result == TRUE); + DD_UNUSED(result); + } + } + + Handle MapProcessBufferView(Handle hBuffer, ProcessId processId) + { + Handle sharedBuffer = kNullPtr; + + HANDLE hProcess = ::OpenProcess(PROCESS_ALL_ACCESS, TRUE /*bInheritHandle*/, static_cast(processId)); + + if (hProcess != nullptr) + { + // Just Duplicate the handle for UMD test + DuplicateHandle( + GetCurrentProcess(), + (HANDLE)hBuffer, + hProcess, + reinterpret_cast(&sharedBuffer), + 0, + TRUE, /*Inherit Handle*/ + DUPLICATE_SAME_ACCESS /*options*/); + + CloseHandle(hProcess); + } + + DD_ALERT(sharedBuffer != kNullPtr); + + return sharedBuffer; + } + } + } +} diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/win/ddWinSocket.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/win/ddWinSocket.cpp new file mode 100644 index 000000000..6661a7cd6 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/win/ddWinSocket.cpp @@ -0,0 +1,534 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2016-2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +#include "../ddSocket.h" + +#pragma comment(lib, "ws2_32.lib") + +#include +#include +#include "ddPlatform.h" + +#include "../session.h" + +namespace DevDriver +{ + static inline Result GetDataError(bool nonBlocking) + { + Result result = Result::Error; + int error = WSAGetLastError(); + switch (error) + { + case WSAEWOULDBLOCK: + if (nonBlocking) + result = Result::NotReady; + break; + case WSAECONNRESET: + case WSAENETUNREACH: + case WSAETIMEDOUT: + result = Result::Unavailable; + break; + } + return result; + } + + // ===================================================================================================================== + // Constructs the Win32 socket this object encapsulates. + Socket::Socket() + : m_osSocket(INVALID_SOCKET) + , m_isNonBlocking(false) + , m_socketType(SocketType::Unknown) + , m_hints() + { + } + + // ===================================================================================================================== + // Frees the Win32 socket this object encapsulates. + Socket::~Socket() + { + // On Windows, there is no "DestroySocket" or equivalent call. + Close(); + } + + // ===================================================================================================================== + // Initializes the Win32 condition variable this object encapsulates. + Result Socket::Init(bool isNonBlocking, SocketType socketType) + { + Result result = Result::Error; + + // Initialize the winsock library. + const WORD requestedVersion = MAKEWORD(2, 2); + WSAData wsaData = {}; + if (WSAStartup(requestedVersion, &wsaData) == 0) + { + m_isNonBlocking = isNonBlocking; + m_socketType = socketType; + + if (m_osSocket == INVALID_SOCKET) + { + switch (socketType) + { + case SocketType::Tcp: + m_osSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + m_hints.ai_family = AF_INET; + m_hints.ai_socktype = SOCK_STREAM; + m_hints.ai_protocol = IPPROTO_TCP; + break; + case SocketType::Udp: + m_osSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); + m_hints.ai_family = AF_INET; + m_hints.ai_socktype = SOCK_DGRAM; + m_hints.ai_protocol = IPPROTO_UDP; + break; + default: + break; + } + + result = (m_osSocket != INVALID_SOCKET) ? Result::Success : Result::Error; + } + + if (result == Result::Success) + { + // Set the exclusive address option + int opt = 1; + int retval = setsockopt(m_osSocket, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char *)&opt, sizeof(opt)); + if (retval == SOCKET_ERROR) + { + result = Result::Error; + } + + // magic number. 2x default window size seems to yield good results + DD_STATIC_CONST int bufferMultiple = 2; + + // set the buffer to 256K + int bufferSize = bufferMultiple * kDefaultWindowSize * kMaxMessageSizeInBytes; + retval = setsockopt(m_osSocket, SOL_SOCKET, SO_SNDBUF, (char *)&bufferSize, sizeof(bufferSize)); + if (retval == SOCKET_ERROR) + { + result = Result::Error; + } + + retval = setsockopt(m_osSocket, SOL_SOCKET, SO_RCVBUF, (char *)&bufferSize, sizeof(bufferSize)); + if (retval == SOCKET_ERROR) + { + result = Result::Error; + } + + if ((result == Result::Success) & m_isNonBlocking) + { + // Enable non blocking mode for the socket. + u_long arg = 1; + result = (ioctlsocket(m_osSocket, FIONBIO, &arg) != SOCKET_ERROR) ? Result::Success + : Result::Error; + } + } + + // Clean up winsock if the socket initialization failed for some reason. + if (result != Result::Success) + { + WSACleanup(); + } + } + + return result; + } + + Result Socket::Connect(const char* pAddress, uint32 port) + { + Result result = Result::Success; + + char portBuffer[16] = {}; + _itoa_s(port, portBuffer, 10); + + addrinfo* pResult = nullptr; + int retVal = getaddrinfo(pAddress, portBuffer, &m_hints, &pResult); + + if (retVal == 0) + { + sockaddr* addr = pResult->ai_addr; + size_t addrSize = pResult->ai_addrlen; + + retVal = connect(m_osSocket, addr, static_cast(addrSize)); + + if (retVal == 0) + { + result = Result::Success; + } + else + { + result = GetDataError(m_isNonBlocking); + } + + freeaddrinfo(pResult); + } + else + { + result = Result::Error; + } + + return result; + } + + Result Socket::Select(bool* pReadState, bool* pWriteState, bool* pExceptState, uint32 timeoutInMs) + { + Result result = Result::Error; + + fd_set readSet = {}; + fd_set writeSet = {}; + fd_set exceptSet = {}; + +#pragma warning(push) +#pragma warning(disable : 4548) + FD_SET(m_osSocket, &readSet); + FD_SET(m_osSocket, &writeSet); + FD_SET(m_osSocket, &exceptSet); +#pragma warning(pop) + + timeval timeoutValue = {}; + timeoutValue.tv_sec = timeoutInMs / 1000; + timeoutValue.tv_usec = (timeoutInMs % 1000) * 1000; + + fd_set* pReadSet = ((pReadState != nullptr) ? &readSet : nullptr); + fd_set* pWriteSet = ((pWriteState != nullptr) ? &writeSet : nullptr); + fd_set* pExceptSet = ((pExceptState != nullptr) ? &exceptSet : nullptr); + + int retval = select(0, pReadSet, pWriteSet, pExceptSet, &timeoutValue); + + if (pReadState != nullptr) + { + *pReadState = (FD_ISSET(m_osSocket, pReadSet) != 0); + } + + if (pWriteState != nullptr) + { + *pWriteState = (FD_ISSET(m_osSocket, pWriteSet) != 0); + } + + if (pExceptState != nullptr) + { + *pExceptState = (FD_ISSET(m_osSocket, pExceptSet) != 0); + } + + if (retval > 0) + { + result = Result::Success; + } + else + { + result = (retval == 0) ? Result::NotReady : Result::Error; + } + return result; + } + + Result Socket::Bind(const char* pAddress, uint32 port) + { + Result result = Result::Error; + + addrinfo hints = m_hints; + + hints.ai_flags = AI_PASSIVE; + + char portBuffer[16] = {}; + _itoa_s(port, portBuffer, 10); + + addrinfo* pResult = nullptr; + int retVal = getaddrinfo(pAddress, portBuffer, &hints, &pResult); + + if (retVal == 0) + { + sockaddr* addr = pResult->ai_addr; + size_t addrSize = pResult->ai_addrlen; + + if (bind(m_osSocket, addr, static_cast(addrSize)) != SOCKET_ERROR) + { + result = Result::Success; + } + + freeaddrinfo(pResult); + } + + return result; + } + + Result Socket::Listen(uint32 backlog) + { + DD_ASSERT(m_socketType == SocketType::Tcp); + + Result result = Result::Error; + + if (listen(m_osSocket, backlog) != SOCKET_ERROR) + { + result = Result::Success; + } + + return result; + } + + Result Socket::Accept(Socket* pClientSocket) + { + DD_ASSERT(m_socketType == SocketType::Tcp); + + Result result = Result::Error; + + sockaddr addr = {}; + int addrSize = sizeof(addr); + + SOCKET clientSocket = accept(m_osSocket, &addr, &addrSize); + if (clientSocket != INVALID_SOCKET) + { + sockaddr_in* pSocket = reinterpret_cast(&addr); + + const UINT addressBufSize = 256; + char addressBuf[addressBufSize]; + const char* pAddress = inet_ntop(AF_INET, reinterpret_cast(&pSocket->sin_addr), addressBuf, addressBufSize); + + UINT port = ntohs(pSocket->sin_port); + + result = pClientSocket->InitAsClient(clientSocket, pAddress, port, m_isNonBlocking); + } + + return result; + } + + Result Socket::LookupAddressInfo(const char* pAddress, uint32 port, size_t addressInfoSize, char* pAddressInfo, size_t *pAddressSize) + { + DD_ASSERT(addressInfoSize >= sizeof(sockaddr)); + Result result = Result::Error; + + char portBuffer[16] = {}; + _itoa_s(port, portBuffer, 10); + + addrinfo* pResult = nullptr; + int retVal = getaddrinfo(pAddress, portBuffer, &m_hints, &pResult); + + if (retVal == 0) + { + sockaddr* addr = pResult->ai_addr; + size_t addrSize = pResult->ai_addrlen; + if (addressInfoSize >= addrSize) + { + memcpy(pAddressInfo, addr, addrSize); + *pAddressSize = addrSize; + result = Result::Success; + } + + freeaddrinfo(pResult); + } + + return result; + } + + Result Socket::Send(const uint8* pData, size_t dataSize, size_t* pBytesSent) + { + Result result = Result::Error; + + int retVal = send(m_osSocket, reinterpret_cast(pData), static_cast(dataSize), 0); + if (retVal > 0) + { + *pBytesSent = retVal; + result = Result::Success; + } + else + { + *pBytesSent = 0; + if (retVal == 0) + { + result = Result::Unavailable; + } + else + { + result = GetDataError(m_isNonBlocking); + } + } + + return result; + } + + Result Socket::SendTo(const void *pSockAddr, size_t addrSize, const uint8 *pData, size_t dataSize) + { + DD_ASSERT(m_socketType == SocketType::Udp); + // DD_ASSERT(addrSize >= sizeof(sockaddr)); + + Result result = Result::Error; + + int retVal = sendto(m_osSocket, + reinterpret_cast(pData), + static_cast(dataSize), + 0, + reinterpret_cast(pSockAddr), + static_cast(addrSize)); + + if (retVal > 0) + { + DD_ASSERT(static_cast(retVal) == dataSize); + result = Result::Success; + } + else + { + if (retVal == 0) + { + result = Result::Unavailable; + } + else + { + result = GetDataError(m_isNonBlocking); + } + } + + return result; + } + + Result Socket::Receive(uint8* pBuffer, size_t bufferSize, size_t* pBytesReceived) + { + //DD_ASSERT(m_socketType == SocketType::Tcp); + + Result result = Result::Error; + + int retVal = recv(m_osSocket, reinterpret_cast(pBuffer), static_cast(bufferSize), 0); + if (retVal > 0) + { + *pBytesReceived = retVal; + result = Result::Success; + } + else + { + *pBytesReceived = 0; + if (retVal == 0) + { + result = Result::Unavailable; + } + else + { + result = GetDataError(m_isNonBlocking); + } + } + return result; + } + + Result Socket::ReceiveFrom(void *pSockAddr, size_t *addrSize, uint8 *pBuffer, size_t bufferSize) + { + DD_ASSERT(m_socketType == SocketType::Udp); + DD_ASSERT(*addrSize >= sizeof(sockaddr)); + + Result result = Result::Error; + + int retVal = recvfrom(m_osSocket, + reinterpret_cast(pBuffer), + static_cast(bufferSize), + 0, + reinterpret_cast(pSockAddr), + reinterpret_cast(addrSize)); + + if (retVal > 0) + { + result = Result::Success; + } + else + { + if (retVal == 0) + { + result = Result::Unavailable; + } + else + { + result = GetDataError(m_isNonBlocking); + } + } + + return result; + } + + Result Socket::Close() + { + Result result = Result::Error; + if (m_osSocket != INVALID_SOCKET) + { + + // Shut down the socket before closing it. + // The result doesn't matter since we're closing it anyways. + shutdown(m_osSocket, SD_BOTH); + + int retVal = closesocket(m_osSocket); + if (retVal != SOCKET_ERROR) + { + result = Result::Success; + } + + // Clean up the winsock library. + WSACleanup(); + m_osSocket = INVALID_SOCKET; + } + return result; + } + + Result Socket::GetSocketName(char *pAddress, size_t addrLen, uint32 *pPort) + { + Result result = Result::Error; + int len = sizeof(sockaddr); + sockaddr addr; + if (getsockname(m_osSocket, &addr, &len) == 0) + { + sockaddr_in* pAddr = reinterpret_cast(&addr); + const char* pResult = inet_ntop(AF_INET, reinterpret_cast(&pAddr->sin_addr), pAddress, addrLen); + + if (pResult != NULL) + { + UINT port = ntohs(pAddr->sin_port); + *pPort = port; + result = Result::Success; + } + } + return result; + } + + Result Socket::InitAsClient(OsSocketType socket, const char* pAddress, uint32 port, bool isNonBlocking) + { + DD_ASSERT(m_socketType == SocketType::Tcp); + + DD_UNUSED(port); + DD_UNUSED(pAddress); + + Result result = Result::Success; + + m_isNonBlocking = isNonBlocking; + + m_osSocket = socket; + + result = (m_osSocket != INVALID_SOCKET) ? Result::Success : Result::Error; + + if (result == Result::Success) + { + if (m_isNonBlocking) + { + // Enable non blocking mode for the socket. + u_long arg = 1; + result = (ioctlsocket(m_osSocket, FIONBIO, &arg) != SOCKET_ERROR) ? Result::Success + : Result::Error; + } + } + + return result; + } + +} // DevDriver diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/win/traceSession.cpp b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/win/traceSession.cpp new file mode 100644 index 000000000..2211c5f89 --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/win/traceSession.cpp @@ -0,0 +1,274 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +//============================================================================= +/// Copyright (c) 2016 Advanced Micro Devices, Inc. All rights reserved. +/// \author AMD Developer Tools Team +/// \file +/// \brief An ETW trace session that can be enable providers and start a realtime event trace. +//============================================================================= + +#include "traceSession.h" +#include +#include + +#include "ddPlatform.h" + +#define SAFE_DELETE(x) {if(x){free(x); (x) = nullptr; }} +#define SAFE_DELETE_ARRAY(x) {if(x){free(x); x = nullptr; }} + +using namespace DevDriver; +//----------------------------------------------------------------------------- +/// Constructor for the TraceSession class. +/// \param sessionName The name of the tracing session. +//----------------------------------------------------------------------------- +TraceSession::TraceSession() + : m_sessionName(TEXT("RDS Trace Session")) + , m_session({}) + , m_traceLogFile({}) + , m_sessionHandle(0) + , m_traceHandle(0) +{ +} + +//----------------------------------------------------------------------------- +/// Destructor for the TraceSession class. +//----------------------------------------------------------------------------- +TraceSession::~TraceSession() +{ +} + +//----------------------------------------------------------------------------- +/// Start the trace session. +/// \returns True when the session was started correctly, and false if it failed. +//----------------------------------------------------------------------------- +bool TraceSession::Start() +{ + bool result = false; + DD_PRINT(LogLevel::Verbose, "[TraceSession::Start] Start called"); + + if (m_sessionHandle == 0) + { + ZeroMemory(&m_session, sizeof(m_session)); + m_session.properties.Wnode.BufferSize = sizeof(m_session); + + // Setting this to "1" means event timestamps will be based on QueryPerformanceCounter. + m_session.properties.Wnode.ClientContext = 1; + m_session.properties.Wnode.Flags = WNODE_FLAG_TRACED_GUID; + m_session.properties.LogFileMode = EVENT_TRACE_REAL_TIME_MODE; + m_session.properties.LoggerNameOffset = sizeof(EVENT_TRACE_PROPERTIES); + m_session.properties.LogFileNameOffset = 0; + + // Create the trace session. + ULONG status = StartTrace(&m_sessionHandle, m_sessionName, &m_session.properties); + + // If we fail to start the trace because one already exists with the same name, attempt to + // stop the existing trace, then start a new one. + if (status == ERROR_ALREADY_EXISTS) + { + // Stop the existing trace. + status = ControlTrace(NULL, m_sessionName, &m_session.properties, EVENT_TRACE_CONTROL_STOP); + if (status == ERROR_SUCCESS) + { + // Start a new trace if we successfully stopped the existing one. + status = StartTrace(&m_sessionHandle, m_sessionName, &m_session.properties); + } + } + + result = (status == ERROR_SUCCESS); + DD_PRINT(LogLevel::Verbose, "[TraceSession::Start] Start: %u", status); + } + return result; +} + +//----------------------------------------------------------------------------- +/// Enable the ETW provider with the incoming GUID. +/// \param providerId The GUID for the provider to enable. +/// \param level The level of detail to provide in each logged event. +/// \param anyKeyword A bitmask to determine the set of events to provide. +/// \param allKeyword A bitmask to restrict the set of event categories to provide. +/// \returns True if enabling the provider was successful, and false if it failed. +//----------------------------------------------------------------------------- +bool TraceSession::EnableProvider(const GUID& providerId, UCHAR level, ULONGLONG anyKeyword, ULONGLONG allKeyword) +{ + bool result = false; + DD_PRINT(LogLevel::Verbose, "[TraceSession::EnableProvider] EnableProvider called"); + + if (m_sessionHandle != 0) + { + ULONG status = EnableTraceEx2(m_sessionHandle, &providerId, EVENT_CONTROL_CODE_ENABLE_PROVIDER, level, anyKeyword, allKeyword, 0, nullptr); + result = (status == ERROR_SUCCESS); + } + return result; +} + +//----------------------------------------------------------------------------- +/// Enable the ETW provider with the incoming GUID string. +/// \param providerId The GUID string for the provider to enable. +/// \param level The level of detail to provide in each logged event. +/// \param anyKeyword A bitmask to determine the set of events to provide. +/// \param allKeyword A bitmask to restrict the set of event categories to provide. +/// \returns True if enabling the provider was successful, and false if it failed. +//----------------------------------------------------------------------------- +bool TraceSession::EnableProviderByGUID(const LPCWSTR& inGUID, UCHAR level, ULONGLONG anyKeyword, ULONGLONG allKeyword) +{ + bool result = false; + DD_PRINT(LogLevel::Verbose, "[TraceSession::EnableProviderByGUID] EnableProviderByGUID called"); + if (m_sessionHandle != 0) + { + GUID providerGuid; + HRESULT converted = CLSIDFromString(inGUID, &providerGuid); + + if (converted == S_OK) + { + ULONG status = EnableTraceEx2(m_sessionHandle, &providerGuid, EVENT_CONTROL_CODE_ENABLE_PROVIDER, level, anyKeyword, allKeyword, 0, nullptr); + result = (status == ERROR_SUCCESS); + DD_PRINT(LogLevel::Verbose, "[TraceSession::EnableProviderByGUID] Provider enabled: %u",status); + } + } + + // Failed to convert the incoming GUID. + return result; +} + +//----------------------------------------------------------------------------- +/// The global callback for all incoming ETW events. +/// \param pEventRecord The ETW event structure raised by the provider. +//----------------------------------------------------------------------------- +VOID WINAPI EventRecordCallback(PEVENT_RECORD pEventRecord) +{ + reinterpret_cast(pEventRecord->UserContext)->OnEventRecord(pEventRecord); +} + +//----------------------------------------------------------------------------- +/// On a trace with the provided consumer. +/// \param pConsumer The consumer to use when opening a new tracing session. +/// \returns True when the trace was opened successfully, and false if it failed. +//----------------------------------------------------------------------------- +bool TraceSession::Open(ETWConsumerBase* pConsumer) +{ + bool result = false; + DD_ASSERT(pConsumer != nullptr); + DD_PRINT(LogLevel::Verbose, "[TraceSession::Open] Open called"); + + if (m_sessionHandle != 0 && m_traceHandle == 0) + { + ZeroMemory(&m_traceLogFile, sizeof(m_traceLogFile)); + m_traceLogFile.LoggerName = m_sessionName; + m_traceLogFile.ProcessTraceMode = PROCESS_TRACE_MODE_REAL_TIME | PROCESS_TRACE_MODE_EVENT_RECORD | PROCESS_TRACE_MODE_RAW_TIMESTAMP; + m_traceLogFile.EventRecordCallback = &EventRecordCallback; + m_traceLogFile.Context = pConsumer; + + m_traceHandle = ::OpenTrace(&m_traceLogFile); + result = (m_traceHandle != 0); + DD_PRINT(LogLevel::Verbose, "[TraceSession::Open] Trace session open: %s", result ? "Successful" : "Unsuccessful"); + + } + return result; +} + +//----------------------------------------------------------------------------- +/// Process all new incoming events from the trace session. +/// \returns True when processing the trace was successful, and false when it fails. +//----------------------------------------------------------------------------- +bool TraceSession::Process() +{ + bool result = false; + if (m_sessionHandle != 0 && m_traceHandle != 0) + { + DD_PRINT(LogLevel::Verbose, "[TraceSession::Process] Process trace starting"); + ULONG status = ProcessTrace(&m_traceHandle, 1, nullptr, nullptr); + DD_PRINT(LogLevel::Verbose, "[TraceSession::Process] Process trace finished"); + result = (status == ERROR_SUCCESS); + } + DD_PRINT(LogLevel::Verbose, + "[TraceSession::Process] Trace session processing: %s", + result ? "Successful" : "Unsuccessful"); + return result; +} + +//----------------------------------------------------------------------------- +/// Close an active trace session. +/// \returns True when the trace was closed successfully, and false if it failed. +//----------------------------------------------------------------------------- +bool TraceSession::Close() +{ + bool result = false; + DD_PRINT(LogLevel::Verbose, "[TraceSession::Close] Trace session closing"); + if (m_sessionHandle != 0 && m_traceHandle != 0) + { + ULONG status = ::CloseTrace(m_traceHandle); + result = (status == ERROR_SUCCESS || status == ERROR_CTX_CLOSE_PENDING); + DD_ASSERT(result); + DD_PRINT(LogLevel::Verbose, "[TraceSession::Close] Trace session close: %u", status); + m_traceHandle = 0; + } + return result; +} + +//----------------------------------------------------------------------------- +/// Disable a trace provider by GUID. +/// \param The GUID for the provider to disable. +/// \returns True when the provider was disabled successfully, and false if it failed. +//----------------------------------------------------------------------------- +bool TraceSession::DisableProvider(const GUID& providerId) +{ + bool result = false; + if (m_sessionHandle != 0) + { + ULONG status = EnableTraceEx2(m_sessionHandle, &providerId, EVENT_CONTROL_CODE_DISABLE_PROVIDER, 0, 0, 0, 0, nullptr); + result = (status == ERROR_SUCCESS); + DD_ASSERT(result); + } + return result; +} + +//----------------------------------------------------------------------------- +/// Stop the tracing sesssion from processing events. +/// \returns True when the trace session was stopped successfully, and false if it failed. +//----------------------------------------------------------------------------- +bool TraceSession::Stop() +{ + bool result = false; + DD_PRINT(LogLevel::Verbose, "[TraceSession::Stop] Trace session stopping"); + if (m_sessionHandle != 0) + { + Close(); + ULONG status = ControlTrace(m_sessionHandle, m_sessionName, &m_session.properties, EVENT_TRACE_CONTROL_STOP); + result = (status == ERROR_SUCCESS); + DD_ASSERT(result); + DD_PRINT(LogLevel::Verbose, "[TraceSession::Stop] Trace session stop: %u", status); + m_sessionHandle = 0; + } + return result; +} + +//----------------------------------------------------------------------------- +/// Retrieve the trace session's timestamp frequency. +/// \returns The trace session's timestamp frequency. +//----------------------------------------------------------------------------- +LONGLONG TraceSession::PerfFreq() const +{ + return m_traceLogFile.LogfileHeader.PerfFreq.QuadPart; +} diff --git a/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/win/traceSession.h b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/win/traceSession.h new file mode 100644 index 000000000..4269ff04c --- /dev/null +++ b/renderdoc/driver/ihv/amd/official/RGP/DevDriverComponents/src/win/traceSession.h @@ -0,0 +1,75 @@ +/* + ******************************************************************************* + * + * Copyright (c) 2018 Advanced Micro Devices, Inc. All rights reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + ******************************************************************************/ + +//============================================================================= +/// Copyright (c) 2016 Advanced Micro Devices, Inc. All rights reserved. +/// \author AMD Developer Tools Team +/// \file +/// \brief An ETW trace session that can be enable providers and start a realtime event trace. +//============================================================================= + +#pragma once + +#include +#include +#include +#include +#include + +/// The baseclass for a realtime ETW consumer. +class ETWConsumerBase +{ +public: + virtual void OnEventRecord(PEVENT_RECORD pEventRecord) = 0; + virtual ~ETWConsumerBase() {} +}; + +/// An ETW trace session that can be enable providers and start a realtime event trace. +class TraceSession +{ +public: + TraceSession(); + ~TraceSession(); + + bool Start(); + bool EnableProvider(const GUID& providerId, UCHAR level, ULONGLONG anyKeyword = 0, ULONGLONG allKeyword = 0); + bool EnableProviderByGUID(const LPCWSTR& guid, UCHAR level, ULONGLONG anyKeyword = 0, ULONGLONG allKeyword = 0); + bool Open(ETWConsumerBase* pConsumer); + bool Process(); + bool Close(); + bool DisableProvider(const GUID& providerId); + bool Stop(); + LONGLONG PerfFreq() const; + +private: + TCHAR m_sessionName[128]; ///< Storage for the ETW session name + struct + { + EVENT_TRACE_PROPERTIES properties; + char name[128]; + } m_session; + EVENT_TRACE_LOGFILE m_traceLogFile; ///< The trace logfile to stream data to. + TRACEHANDLE m_sessionHandle; ///< The ETW trace session handle. + TRACEHANDLE m_traceHandle; ///< The handle for the active ETW trace. +}; diff --git a/renderdoc/renderdoc.vcxproj b/renderdoc/renderdoc.vcxproj index 83939bf30..f947f7076 100644 --- a/renderdoc/renderdoc.vcxproj +++ b/renderdoc/renderdoc.vcxproj @@ -78,9 +78,10 @@ Windows - ws2_32.lib;kernel32.lib;user32.lib;shlwapi.lib;%(AdditionalDependencies) + tdh.lib;ws2_32.lib;kernel32.lib;user32.lib;shlwapi.lib;%(AdditionalDependencies) $(ProjectDir)os\win32\comexport.def true + tdh.dll true @@ -536,6 +537,9 @@ {40349ad9-5558-4df4-84e2-11934de90a11} + + {b33f8ffd-3c04-4779-9c3b-e2858387971b} + {88c5dac6-30a0-4cfd-af51-540a977d1f3f}