/// <summary>
/// This API gets information about the given setting.
/// </summary>
/// <param name="sessionHandle">Input to the session handle.</param>
/// <param name="profileHandle">Input profile handle.</param>
/// <param name="settingId">Input settingId.</param>
/// <returns>An instance of <see cref="DRSSettingV1" /> describing the setting if found; otherwise <see langword="null" />.</returns>
public static DRSSettingV1?GetSetting(
DRSSessionHandle sessionHandle,
DRSProfileHandle profileHandle,
uint settingId)
{
var instance = typeof(DRSSettingV1).Instantiate <DRSSettingV1>();
using (var settingReference = ValueTypeReference.FromValueType(instance, typeof(DRSSettingV1)))
{
var status = DelegateFactory.GetDelegate <Delegates.DRS.NvAPI_DRS_GetSetting>()(
sessionHandle,
profileHandle,
settingId,
settingReference
);
if (status == Status.IncompatibleStructureVersion)
{
throw new NVIDIANotSupportedException("This operation is not supported.");
}
if (status == Status.SettingNotFound)
{
return(null);
}
if (status != Status.Ok)
{
throw new NVIDIAApiException(status);
}
return(settingReference.ToValueType <DRSSettingV1>(typeof(DRSSettingV1)));
}
}
/// <summary>
/// This API returns information on the topologies and display resolutions supported by Mosaic mode.
/// NOTE: Not all topologies returned can be set immediately. Some of the topologies returned might not be valid for
/// one reason or another. It could be due to mismatched or missing displays. It could also be because the required
/// number of GPUs is not found.
/// Once you get the list of supported topologies, you can call GetTopologyGroup() with one of the Mosaic topologies if
/// you need more information about it.
/// It is possible for this function to return NVAPI_OK with no topologies listed in the return structure. If this is
/// the case, it means that the current hardware DOES support Mosaic, but with the given configuration no valid
/// topologies were found. This most likely means that SLI was not enabled for the hardware. Once enabled, you should
/// see valid topologies returned from this function.
/// </summary>
/// <param name="topologyType">The type of topologies the caller is interested in getting.</param>
/// <returns>Information about what topologies and display resolutions are supported for Mosaic.</returns>
/// <exception cref="NVIDIAApiException">Status.NotSupported: Mosaic is not supported with the existing hardware.</exception>
/// <exception cref="NVIDIAApiException">Status.InvalidArgument: TopologyType is invalid.</exception>
/// <exception cref="NVIDIAApiException">Status.ApiNotInitialized: The NvAPI API needs to be initialized first.</exception>
/// <exception cref="NVIDIAApiException">Status.NoImplementation: This entry-point not available.</exception>
/// <exception cref="NVIDIAApiException">Status.Error: Miscellaneous error occurred.</exception>
/// <exception cref="NVIDIANotSupportedException">This operation is not supported.</exception>
/// <exception cref="Exception">A delegate callback throws an exception.</exception>
public static ISupportedTopologiesInfo GetSupportedTopologiesInfo(TopologyType topologyType)
{
var mosaicGetSupportedTopoInfo =
DelegateFactory.GetDelegate <Delegates.Mosaic.NvAPI_Mosaic_GetSupportedTopoInfo>();
foreach (var acceptType in mosaicGetSupportedTopoInfo.Accepts())
{
var instance = acceptType.Instantiate <ISupportedTopologiesInfo>();
using (var supportedTopologiesInfoByRef = ValueTypeReference.FromValueType(instance, acceptType))
{
var status = mosaicGetSupportedTopoInfo(supportedTopologiesInfoByRef, topologyType);
if (status == Status.IncompatibleStructureVersion)
{
continue;
}
if (status != Status.Ok)
{
throw new NVIDIAApiException(status);
}
return(supportedTopologiesInfoByRef.ToValueType <ISupportedTopologiesInfo>(acceptType));
}
}
throw new NVIDIANotSupportedException("This operation is not supported.");
}
/// <summary>
/// This API adds an executable name to a profile.
/// </summary>
/// <param name="sessionHandle">Input to the session handle.</param>
/// <param name="profileHandle">Input profile handle.</param>
/// <param name="application">Input <see cref="IDRSApplication" /> instance containing the executable name.</param>
/// <returns>The newly created instance of <see cref="IDRSApplication" />.</returns>
public static IDRSApplication CreateApplication(
DRSSessionHandle sessionHandle,
DRSProfileHandle profileHandle,
IDRSApplication application)
{
using (var applicationReference = ValueTypeReference.FromValueType(application, application.GetType()))
{
var status = DelegateFactory.GetDelegate <Delegates.DRS.NvAPI_DRS_CreateApplication>()(
sessionHandle,
profileHandle,
applicationReference
);
if (status == Status.IncompatibleStructureVersion)
{
throw new NVIDIANotSupportedException("This operation is not supported.");
}
if (status != Status.Ok)
{
throw new NVIDIAApiException(status);
}
return(applicationReference.ToValueType <IDRSApplication>(application.GetType()));
}
}
/// <summary>
/// This function returns information about the system's chipset.
/// </summary>
/// <returns>Information about the system's chipset</returns>
/// <exception cref="NVIDIANotSupportedException">This operation is not supported.</exception>
/// <exception cref="NVIDIAApiException">Status.InvalidArgument: Invalid argument</exception>
/// <exception cref="Exception">A delegate callback throws an exception.</exception>
public static IChipsetInfo GetChipsetInfo()
{
var getChipSetInfo = DelegateFactory.GetDelegate <Delegates.General.NvAPI_SYS_GetChipSetInfo>();
foreach (var acceptType in getChipSetInfo.Accepts())
{
var instance = acceptType.Instantiate <IChipsetInfo>();
using (var chipsetInfoReference = ValueTypeReference.FromValueType(instance, acceptType))
{
var status = getChipSetInfo(chipsetInfoReference);
if (status == Status.IncompatibleStructureVersion)
{
continue;
}
if (status != Status.Ok)
{
throw new NVIDIAApiException(status);
}
return(chipsetInfoReference.ToValueType <IChipsetInfo>(acceptType));
}
}
throw new NVIDIANotSupportedException("This operation is not supported.");
}
/// <summary>
/// This function returns the EDID data for the specified GPU handle and connection bit mask.
/// outputId should have exactly 1 bit set to indicate a single display.
/// </summary>
/// <param name="gpuHandle">Physical GPU handle to check outputs</param>
/// <param name="outputId">Output identification</param>
/// <returns>Whole or a part of the EDID data</returns>
/// <exception cref="NVIDIANotSupportedException">This operation is not supported.</exception>
/// <exception cref="NVIDIAApiException">
/// Status.InvalidArgument: gpuHandle or edid is invalid, outputId has 0 or > 1 bits
/// set
/// </exception>
/// <exception cref="NVIDIAApiException">Status.NvidiaDeviceNotFound: No NVIDIA GPU driving a display was found.</exception>
/// <exception cref="NVIDIAApiException">Status.ExpectedPhysicalGPUHandle: gpuHandle was not a physical GPU handle.</exception>
/// <exception cref="NVIDIAApiException">Status.DataNotFound: The requested display does not contain an EDID.</exception>
/// <exception cref="Exception">A delegate callback throws an exception.</exception>
public static IEDID GetEDID(PhysicalGPUHandle gpuHandle, OutputId outputId)
{
var gpuGetEDID = DelegateFactory.GetDelegate <Delegates.GPU.NvAPI_GPU_GetEDID>();
foreach (var acceptType in gpuGetEDID.Accepts())
{
using (var edidReference = ValueTypeReference.FromValueType(acceptType.Instantiate <IEDID>(), acceptType)
)
{
var status = gpuGetEDID(gpuHandle, outputId, edidReference);
if (status == Status.IncompatibleStructureVersion)
{
continue;
}
if (status != Status.Ok)
{
throw new NVIDIAApiException(status);
}
return(edidReference.ToValueType <IEDID>(acceptType));
}
}
throw new NVIDIANotSupportedException("This operation is not supported.");
}
/// <summary>
/// [PRIVATE]
/// Gets the cooler policy table for the passed GPU handle.
/// </summary>
/// <param name="gpuHandle">The handle of the GPU to perform the operation on.</param>
/// <param name="policy">The cooler policy to get the table for.</param>
/// <param name="index">The cooler index.</param>
/// <param name="count">Number of policy table entries retrieved.</param>
/// <returns>The cooler policy table for the GPU.</returns>
// ReSharper disable once TooManyArguments
public static PrivateCoolerPolicyTableV1 GetCoolerPolicyTable(
PhysicalGPUHandle gpuHandle,
CoolerPolicy policy,
uint index,
out uint count)
{
var instance = typeof(PrivateCoolerPolicyTableV1).Instantiate <PrivateCoolerPolicyTableV1>();
instance._Policy = policy;
using (var policyTableReference = ValueTypeReference.FromValueType(instance))
{
var status = DelegateFactory.GetDelegate <Delegates.GPU.NvAPI_GPU_GetCoolerPolicyTable>()(
gpuHandle,
index,
policyTableReference,
out count
);
if (status != Status.Ok)
{
throw new NVIDIAApiException(status);
}
return(policyTableReference.ToValueType <PrivateCoolerPolicyTableV1>(typeof(PrivateCoolerPolicyTableV1)));
}
}
/// <summary>
/// This API sets the Mosaic topology and performs a mode switch using the given display settings.
/// </summary>
/// <param name="topoBrief">
/// The topology to set. This must be one of the topologies returned from GetSupportedTopoInfo(),
/// and it must have an isPossible value of true.
/// </param>
/// <param name="displaySettings">
/// The per display settings to be used in the Mosaic mode. This must be one of the settings
/// returned from GetSupportedTopoInfo().
/// </param>
/// <param name="overlapX">
/// The pixel overlap to use between horizontal displays (use positive a number for overlap, or a
/// negative number to create a gap.) If the overlap is out of bounds for what is possible given the topo and display
/// setting, the overlap will be clamped.
/// </param>
/// <param name="overlapY">
/// The pixel overlap to use between vertical displays (use positive a number for overlap, or a
/// negative number to create a gap.) If the overlap is out of bounds for what is possible given the topo and display
/// setting, the overlap will be clamped.
/// </param>
/// <param name="enable">
/// If true, the topology being set will also be enabled, meaning that the mode set will occur. If
/// false, you don't want to be in Mosaic mode right now, but want to set the current Mosaic topology so you can enable
/// it later with EnableCurrentTopo()
/// </param>
/// <exception cref="ArgumentException">displaySettings is of invalid type.</exception>
/// <exception cref="NVIDIAApiException">Status.NotSupported: Mosaic is not supported with the existing hardware.</exception>
/// <exception cref="NVIDIAApiException">Status.InvalidArgument: One or more arguments passed in are invalid.</exception>
/// <exception cref="NVIDIAApiException">Status.ApiNotInitialized: The NvAPI API needs to be initialized first.</exception>
/// <exception cref="NVIDIAApiException">Status.NoImplementation: This entry point not available.</exception>
/// <exception cref="NVIDIAApiException">Status.Error: Miscellaneous error occurred.</exception>
/// <exception cref="Exception">A delegate callback throws an exception.</exception>
// ReSharper disable once TooManyArguments
public static void SetCurrentTopology(
TopologyBrief topoBrief,
IDisplaySettings displaySettings,
int overlapX,
int overlapY,
bool enable)
{
var mosaicSetCurrentTopo = DelegateFactory.GetDelegate <Delegates.Mosaic.NvAPI_Mosaic_SetCurrentTopo>();
if (!mosaicSetCurrentTopo.Accepts().Contains(displaySettings.GetType()))
{
throw new ArgumentException("Parameter type is not supported.", nameof(displaySettings));
}
using (
var displaySettingsByRef = ValueTypeReference.FromValueType(displaySettings, displaySettings.GetType()))
{
var status = mosaicSetCurrentTopo(topoBrief, displaySettingsByRef, overlapX, overlapY,
(uint)(enable ? 1 : 0));
if (status != Status.Ok)
{
throw new NVIDIAApiException(status);
}
}
}
/// <summary>
/// This function retrieves the available driver memory footprint for the specified GPU.
/// If the GPU is in TCC Mode, only dedicatedVideoMemory will be returned.
/// </summary>
/// <param name="physicalGPUHandle">Handle of the physical GPU for which the memory information is to be extracted.</param>
/// <returns>The memory footprint available in the driver.</returns>
/// <exception cref="NVIDIANotSupportedException">This operation is not supported.</exception>
/// <exception cref="NVIDIAApiException">Status.NvidiaDeviceNotFound: No NVIDIA GPU driving a display was found.</exception>
/// <exception cref="Exception">A delegate callback throws an exception.</exception>
public static IDisplayDriverMemoryInfo GetMemoryInfo(PhysicalGPUHandle physicalGPUHandle)
{
var getMemoryInfo = DelegateFactory.GetDelegate <Delegates.GPU.NvAPI_GPU_GetMemoryInfo>();
foreach (var acceptType in getMemoryInfo.Accepts())
{
var instance = acceptType.Instantiate <IDisplayDriverMemoryInfo>();
using (var displayDriverMemoryInfo = ValueTypeReference.FromValueType(instance, acceptType))
{
var status = getMemoryInfo(physicalGPUHandle, displayDriverMemoryInfo);
if (status == Status.IncompatibleStructureVersion)
{
continue;
}
if (status != Status.Ok)
{
throw new NVIDIAApiException(status);
}
return(displayDriverMemoryInfo.ToValueType <IDisplayDriverMemoryInfo>(acceptType));
}
}
throw new NVIDIANotSupportedException("This operation is not supported.");
}
/// <summary>
/// This function returns the EDID data for the specified GPU handle and connection bit mask.
/// outputId should have exactly 1 bit set to indicate a single display.
/// </summary>
/// <param name="gpuHandle">Physical GPU handle to check outputs</param>
/// <param name="outputId">Output identification</param>
/// <param name="offset">EDID offset</param>
/// <param name="readIdentification">EDID read identification for multi part read, or zero for first run</param>
/// <returns>Whole or a part of the EDID data</returns>
/// <exception cref="NVIDIANotSupportedException">This operation is not supported.</exception>
/// <exception cref="NVIDIAApiException">
/// Status.InvalidArgument: gpuHandle or edid is invalid, outputId has 0 or > 1 bits
/// set
/// </exception>
/// <exception cref="NVIDIAApiException">Status.NvidiaDeviceNotFound: No NVIDIA GPU driving a display was found.</exception>
/// <exception cref="NVIDIAApiException">Status.ExpectedPhysicalGPUHandle: gpuHandle was not a physical GPU handle.</exception>
/// <exception cref="NVIDIAApiException">Status.DataNotFound: The requested display does not contain an EDID.</exception>
/// <exception cref="Exception">A delegate callback throws an exception.</exception>
// ReSharper disable once TooManyArguments
public static EDIDV3 GetEDID(
PhysicalGPUHandle gpuHandle,
OutputId outputId,
int offset,
int readIdentification = 0)
{
var gpuGetEDID = DelegateFactory.GetDelegate <Delegates.GPU.NvAPI_GPU_GetEDID>();
if (!gpuGetEDID.Accepts().Contains(typeof(EDIDV3)))
{
throw new NVIDIANotSupportedException("This operation is not supported.");
}
var instance = EDIDV3.CreateWithOffset((uint)readIdentification, (uint)offset);
using (var edidReference = ValueTypeReference.FromValueType(instance))
{
var status = gpuGetEDID(gpuHandle, outputId, edidReference);
if (status != Status.Ok)
{
throw new NVIDIAApiException(status);
}
return(edidReference.ToValueType <EDIDV3>().GetValueOrDefault());
}
}
/// <summary>
/// This API returns the X and Y overlap limits required if the given Mosaic topology and display settings are to be
/// used.
/// </summary>
/// <param name="topoBrief">
/// The topology for getting limits This must be one of the topo briefs returned from
/// GetSupportedTopoInfo().
/// </param>
/// <param name="displaySettings">
/// The display settings for getting the limits. This must be one of the settings returned
/// from GetSupportedTopoInfo().
/// </param>
/// <param name="minOverlapX">X overlap minimum</param>
/// <param name="maxOverlapX">X overlap maximum</param>
/// <param name="minOverlapY">Y overlap minimum</param>
/// <param name="maxOverlapY">Y overlap maximum</param>
/// <exception cref="ArgumentException">displaySettings is of invalid type.</exception>
/// <exception cref="NVIDIAApiException">Status.NotSupported: Mosaic is not supported with the existing hardware.</exception>
/// <exception cref="NVIDIAApiException">Status.InvalidArgument: One or more arguments passed in are invalid.</exception>
/// <exception cref="NVIDIAApiException">Status.ApiNotInitialized: The NvAPI API needs to be initialized first.</exception>
/// <exception cref="NVIDIAApiException">Status.NoImplementation: This entry point not available.</exception>
/// <exception cref="NVIDIAApiException">Status.Error: Miscellaneous error occurred.</exception>
/// <exception cref="Exception">A delegate callback throws an exception.</exception>
// ReSharper disable once TooManyArguments
public static void GetOverlapLimits(
TopologyBrief topoBrief,
IDisplaySettings displaySettings,
out int minOverlapX,
out int maxOverlapX,
out int minOverlapY,
out int maxOverlapY)
{
var mosaicGetOverlapLimits = DelegateFactory.GetDelegate <Delegates.Mosaic.NvAPI_Mosaic_GetOverlapLimits>();
if (!mosaicGetOverlapLimits.Accepts().Contains(displaySettings.GetType()))
{
throw new ArgumentException("Parameter type is not supported.", nameof(displaySettings));
}
using (
var displaySettingsByRef = ValueTypeReference.FromValueType(displaySettings, displaySettings.GetType()))
{
var status = mosaicGetOverlapLimits(topoBrief, displaySettingsByRef, out minOverlapX, out maxOverlapX,
out minOverlapY, out maxOverlapY);
if (status != Status.Ok)
{
throw new NVIDIAApiException(status);
}
}
}
/// <summary>
/// This API enumerates all available setting values for a given setting.
/// </summary>
/// <param name="settingId">Input settingId.</param>
/// <returns>All available setting values.</returns>
public static DRSSettingValues EnumAvailableSettingValues(uint settingId)
{
var settingValuesCount = (uint)DRSSettingValues.MaximumNumberOfValues;
var settingValues = typeof(DRSSettingValues).Instantiate <DRSSettingValues>();
using (var settingValuesReference = ValueTypeReference.FromValueType(settingValues))
{
var status = DelegateFactory.GetDelegate <Delegates.DRS.NvAPI_DRS_EnumAvailableSettingValues>()(
settingId,
ref settingValuesCount,
settingValuesReference
);
if (status == Status.IncompatibleStructureVersion)
{
throw new NVIDIANotSupportedException("This operation is not supported.");
}
if (status != Status.Ok)
{
throw new NVIDIAApiException(status);
}
return(settingValuesReference.ToValueType <DRSSettingValues>(typeof(DRSSettingValues)));
}
}
/// <summary>
/// This function retrieves the thermal information of all thermal sensors or specific thermal sensor associated with
/// the selected GPU. To retrieve info for all sensors, set sensorTarget to ThermalSettingsTarget.All.
/// </summary>
/// <param name="physicalGPUHandle">Handle of the physical GPU for which the memory information is to be extracted.</param>
/// <param name="sensorTarget">Specifies the requested thermal sensor target.</param>
/// <returns>The device thermal sensors information.</returns>
/// <exception cref="NVIDIANotSupportedException">This operation is not supported.</exception>
/// <exception cref="NVIDIAApiException">Status.NvidiaDeviceNotFound: No NVIDIA GPU driving a display was found.</exception>
/// <exception cref="Exception">A delegate callback throws an exception.</exception>
public static IThermalSettings GetThermalSettings(
PhysicalGPUHandle physicalGPUHandle,
ThermalSettingsTarget sensorTarget = ThermalSettingsTarget.All)
{
var getThermalSettings = DelegateFactory.GetDelegate <Delegates.GPU.NvAPI_GPU_GetThermalSettings>();
foreach (var acceptType in getThermalSettings.Accepts())
{
var instance = acceptType.Instantiate <IThermalSettings>();
using (var gpuThermalSettings = ValueTypeReference.FromValueType(instance, acceptType))
{
var status = getThermalSettings(physicalGPUHandle, sensorTarget, gpuThermalSettings);
if (status == Status.IncompatibleStructureVersion)
{
continue;
}
if (status != Status.Ok)
{
throw new NVIDIAApiException(status);
}
return(gpuThermalSettings.ToValueType <IThermalSettings>(acceptType));
}
}
throw new NVIDIANotSupportedException("This operation is not supported.");
}
/// <summary>
/// This API returns information for the current Mosaic topology.
/// This includes topology, display settings, and overlap values.
/// You can call NvAPI_Mosaic_GetTopoGroup() with the topology if you require more information.
/// If there isn't a current topology, then TopologyBrief.Topology will be Topology.None.
/// </summary>
/// <param name="topoBrief">The current Mosaic topology</param>
/// <param name="displaySettings">The current per-display settings</param>
/// <param name="overlapX">The pixel overlap between horizontal displays</param>
/// <param name="overlapY">The pixel overlap between vertical displays</param>
/// <exception cref="NVIDIAApiException">Status.NotSupported: Mosaic is not supported with the existing hardware.</exception>
/// <exception cref="NVIDIAApiException">Status.InvalidArgument: One or more argumentss passed in are invalid.</exception>
/// <exception cref="NVIDIAApiException">Status.ApiNotInitialized: The NvAPI API needs to be initialized first.</exception>
/// <exception cref="NVIDIAApiException">Status.NoImplementation: This entry point not available.</exception>
/// <exception cref="NVIDIAApiException">Status.Error: Miscellaneous error occurred.</exception>
/// <exception cref="NVIDIANotSupportedException">This operation is not supported.</exception>
public static void GetCurrentTopology(out TopologyBrief topoBrief, out IDisplaySettings displaySettings,
out int overlapX, out int overlapY)
{
var mosaicGetCurrentTopo = DelegateFactory.Get <Delegates.Mosaic.NvAPI_Mosaic_GetCurrentTopo>();
topoBrief = typeof(TopologyBrief).Instantiate <TopologyBrief>();
foreach (var acceptType in mosaicGetCurrentTopo.Accepts())
{
displaySettings = acceptType.Instantiate <IDisplaySettings>();
using (var displaySettingsByRef = ValueTypeReference.FromValueType(displaySettings, acceptType))
{
var status = mosaicGetCurrentTopo(ref topoBrief, displaySettingsByRef, out overlapX, out overlapY);
if (status == Status.IncompatibleStructureVersion)
{
continue;
}
if (status != Status.Ok)
{
throw new NVIDIAApiException(status);
}
displaySettings = displaySettingsByRef.ToValueType <IDisplaySettings>(acceptType);
return;
}
}
throw new NVIDIANotSupportedException("This operation is not supported.");
}
/// <summary>
/// This API enables and sets up per-pixel intensity feature on the specified display.
/// </summary>
/// <param name="displayId">Combined physical display and GPU identifier of the display to apply the intensity control.</param>
/// <param name="scanOutIntensity">The intensity texture info.</param>
/// <param name="isSticky">Indicates whether the settings will be kept over a reboot.</param>
public static void SetScanOutIntensity(uint displayId, IScanOutIntensity scanOutIntensity, out bool isSticky)
{
Status status;
int isStickyInt;
if (scanOutIntensity == null)
{
status = DelegateFactory.GetDelegate <Delegates.Display.NvAPI_GPU_SetScanOutIntensity>()(
displayId,
ValueTypeReference.Null,
out isStickyInt
);
}
else
{
using (var scanOutWarpingReference =
ValueTypeReference.FromValueType(scanOutIntensity, scanOutIntensity.GetType()))
{
status = DelegateFactory.GetDelegate <Delegates.Display.NvAPI_GPU_SetScanOutIntensity>()(
displayId,
scanOutWarpingReference,
out isStickyInt
);
}
}
if (status != Status.Ok)
{
throw new NVIDIAApiException(status);
}
isSticky = isStickyInt > 0;
}
/// <summary>
/// This API queries the desktop and scan-out portion of the specified display.
/// </summary>
/// <param name="displayId">Combined physical display and GPU identifier of the display to query the configuration.</param>
/// <param name="desktopRectangle">Desktop area of the display in desktop coordinates.</param>
/// <param name="scanOutRectangle">Scan-out area of the display relative to desktopRect.</param>
public static void GetScanOutConfiguration(
uint displayId,
out Rectangle desktopRectangle,
out Rectangle scanOutRectangle)
{
var instance1 = typeof(Rectangle).Instantiate <Rectangle>();
var instance2 = typeof(Rectangle).Instantiate <Rectangle>();
using (var desktopRectangleReference = ValueTypeReference.FromValueType(instance1))
{
using (var scanOutRectangleReference = ValueTypeReference.FromValueType(instance2))
{
var status = DelegateFactory.GetDelegate <Delegates.Display.NvAPI_GPU_GetScanOutConfiguration>()(
displayId,
desktopRectangleReference,
scanOutRectangleReference
);
if (status != Status.Ok)
{
throw new NVIDIAApiException(status);
}
desktopRectangle = desktopRectangleReference.ToValueType <Rectangle>().GetValueOrDefault();
scanOutRectangle = scanOutRectangleReference.ToValueType <Rectangle>().GetValueOrDefault();
}
}
}
/// <summary>
/// This function retrieves the dynamic performance states information from specific GPU
/// </summary>
/// <param name="physicalGPUHandle">Handle of the physical GPU for which the memory information is to be extracted.</param>
/// <returns>The device utilizations information array.</returns>
/// <exception cref="NVIDIANotSupportedException">This operation is not supported.</exception>
/// <exception cref="NVIDIAApiException">Status.NvidiaDeviceNotFound: No NVIDIA GPU driving a display was found.</exception>
/// <exception cref="Exception">A delegate callback throws an exception.</exception>
public static DynamicPerformanceStatesInfoV1 GetDynamicPerformanceStatesInfoEx(
PhysicalGPUHandle physicalGPUHandle)
{
var getDynamicPerformanceStatesInfoEx =
DelegateFactory.GetDelegate <Delegates.GPU.NvAPI_GPU_GetDynamicPStatesInfoEx>();
foreach (var acceptType in getDynamicPerformanceStatesInfoEx.Accepts())
{
var instance = acceptType.Instantiate <DynamicPerformanceStatesInfoV1>();
using (var gpuDynamicPStateInfo = ValueTypeReference.FromValueType(instance, acceptType))
{
var status = getDynamicPerformanceStatesInfoEx(physicalGPUHandle, gpuDynamicPStateInfo);
if (status == Status.IncompatibleStructureVersion)
{
continue;
}
if (status != Status.Ok)
{
throw new NVIDIAApiException(status);
}
return(gpuDynamicPStateInfo.ToValueType <DynamicPerformanceStatesInfoV1>(acceptType));
}
}
throw new NVIDIANotSupportedException("This operation is not supported.");
}
/// <summary>
/// Creates a new PathInfoV2
/// </summary>
/// <param name="sourceId">Source Id, can be zero</param>
public PathInfoV2(uint sourceId)
{
this = typeof(PathInfoV2).Instantiate <PathInfoV2>();
_TargetInfoCount = 0;
_TargetsInfo = ValueTypeArray <PathTargetInfoV2> .Null;
_SourceModeInfo = ValueTypeReference <SourceModeInfo> .Null;
_SourceId = sourceId;
}
void IAllocatable.Allocate()
{
if (_Details.IsNull)
{
var detail = typeof(PathAdvancedTargetInfo).Instantiate <PathAdvancedTargetInfo>();
_Details = ValueTypeReference <PathAdvancedTargetInfo> .FromValueType(detail);
}
}
/// <summary>
/// Creates a new PathInfoV2
/// </summary>
/// <param name="targetInformations">Information about path targets</param>
/// <param name="sourceId">Source Id, can be zero</param>
public PathInfoV2(PathTargetInfoV2[] targetInformations, uint sourceId = 0)
{
this = typeof(PathInfoV2).Instantiate <PathInfoV2>();
_TargetInfoCount = (uint)targetInformations.Length;
_TargetsInfo = ValueTypeArray <PathTargetInfoV2> .FromArray(targetInformations);
_SourceModeInfo = ValueTypeReference <SourceModeInfo> .Null;
_SourceId = sourceId;
}
/// <summary>
/// Creates a new PathInfoV1
/// </summary>
/// <param name="sourceModeInfo">Source mode information</param>
/// <param name="sourceId">Source Id, can be zero</param>
public PathInfoV1(SourceModeInfo sourceModeInfo, uint sourceId)
{
this = typeof(PathInfoV1).Instantiate <PathInfoV1>();
_TargetInfoCount = 0;
_TargetsInfo = ValueTypeArray <PathTargetInfoV1> .Null;
_SourceModeInfo = ValueTypeReference <SourceModeInfo> .FromValueType(sourceModeInfo);
_ReservedSourceId = sourceId;
}
/// <summary>
/// Computes the target partition for each item in the ReadOnlyDataBlock
/// </summary>
/// <param name="table">Table where values will be added</param>
/// <param name="values">DataBlock containing values to be added to the table</param>
/// <param name="idColumnIndex">Index of the id column</param>
/// <param name="partitionIds">[Out] array of the partition ids for each element</param>
public void ComputePartition(Table table, DataBlock.ReadOnlyDataBlock values, int idColumnIndex, out int[] partitionIds, out TargetPartitionInfo[] partitionInfo)
{
int rowCount = values.RowCount;
// TODO: [danny chen] it would be nice if I could get rid of this tunneling of GetColumn
// from the ReadOnlyDataBlock (and avoid the special casing for non-projected blocks)
// but I can't see a way to allow strongly types random access without a bunch of work
// incurred on each access (fetch, cast the array).
T[] idColumn = (T[])values.GetColumn(idColumnIndex);
int[] localPartitionIds = new int[rowCount];
TargetPartitionInfo[] localPartitionInfo = new TargetPartitionInfo[table.PartitionCount];
var rangePartitioner = Partitioner.Create(0, rowCount);
Parallel.ForEach(rangePartitioner,
delegate(Tuple <int, int> range, ParallelLoopState unused)
{
ValueTypeReference <T> vtr = new ValueTypeReference <T>();
Value v = Value.Create(null);
for (int i = range.Item1; i < range.Item2; ++i)
{
// Hash the ID for each item and compute the partition that the item belongs to
vtr.Value = idColumn[i];
v.Assign(vtr);
int idHash = v.GetHashCode();
int partitionId = PartitionMask.IndexOfHash(idHash, table._partitionBits);
localPartitionIds[i] = partitionId;
Interlocked.Increment(ref localPartitionInfo[partitionId].Count);
}
});
int nextStartIndex = 0;
for (int i = 0; i < table.PartitionCount; ++i)
{
if (localPartitionInfo[i].Count == 0)
{
localPartitionInfo[i].StartIndex = -1;
}
else
{
localPartitionInfo[i].StartIndex = nextStartIndex;
nextStartIndex += localPartitionInfo[i].Count;
// NOTE: Count field is cleared here because it is
// reused to track per-partition indexes when
// building up the sort key data
localPartitionInfo[i].Count = 0;
}
}
partitionIds = localPartitionIds;
partitionInfo = localPartitionInfo;
}
/// <summary>
/// Creates a new PathInfoV1
/// </summary>
/// <param name="targetInformations">Information about path targets</param>
/// <param name="sourceModeInfo">Source mode information</param>
/// <param name="sourceId">Source Id, can be zero</param>
public PathInfoV1(PathTargetInfoV1[] targetInformations, SourceModeInfo sourceModeInfo, uint sourceId = 0)
{
this = typeof(PathInfoV1).Instantiate <PathInfoV1>();
_TargetInfoCount = (uint)targetInformations.Length;
_TargetsInfo = ValueTypeArray <PathTargetInfoV1> .FromArray(targetInformations);
_SourceModeInfo = ValueTypeReference <SourceModeInfo> .FromValueType(sourceModeInfo);
_ReservedSourceId = sourceId;
}
void IAllocatable.Allocate()
{
if ((_TargetInfoCount > 0) && _TargetsInfo.IsNull)
{
var targetInfo = typeof(PathTargetInfoV2).Instantiate <PathTargetInfoV2>();
var targetInfoList = targetInfo.Repeat((int)_TargetInfoCount).AllocateAll();
_TargetsInfo = ValueTypeArray <PathTargetInfoV2> .FromArray(targetInfoList.ToArray());
}
if (_SourceModeInfo.IsNull)
{
var sourceModeInfo = typeof(SourceModeInfo).Instantiate <SourceModeInfo>();
_SourceModeInfo = ValueTypeReference <SourceModeInfo> .FromValueType(sourceModeInfo);
}
}
public static void SetClientFanCoolersControl(PhysicalGPUHandle gpuHandle, PrivateFanCoolersControlV1 control)
{
using (var coolerLevelsReference = ValueTypeReference.FromValueType(control))
{
var status = DelegateFactory.GetDelegate <Delegates.GPU.NvAPI_GPU_ClientFanCoolersSetControl>()(
gpuHandle,
coolerLevelsReference
);
if (status != Status.Ok)
{
throw new NVIDIAApiException(status);
}
}
}
/// <summary>
/// [PRIVATE] - [Pascal Only]
/// Sets the clock boost table for the passed GPU handle.
/// </summary>
/// <param name="gpuHandle">The handle of the GPU to perform the operation on.</param>
/// <param name="clockBoostTable">The new clock table.</param>
public static void SetClockBoostTable(PhysicalGPUHandle gpuHandle, PrivateClockBoostTableV1 clockBoostTable)
{
using (var clockTableReference = ValueTypeReference.FromValueType(clockBoostTable))
{
var status = DelegateFactory.GetDelegate <Delegates.GPU.NvAPI_GPU_SetClockBoostTable>()(
gpuHandle,
clockTableReference
);
if (status != Status.Ok)
{
throw new NVIDIAApiException(status);
}
}
}
/// <summary>
/// This function retrieves the clock frequencies information from an specific physical GPU and fills the structure
/// </summary>
/// <param name="physicalGPUHandle">
/// Handle of the physical GPU for which the clock frequency information is to be
/// retrieved.
/// </param>
/// <param name="clockFrequencyOptions">
/// The structure that holds options for the operations and should be filled with the
/// results, use null to return current clock frequencies
/// </param>
/// <returns>The device clock frequencies information.</returns>
/// <exception cref="NVIDIANotSupportedException">This operation is not supported.</exception>
/// <exception cref="NVIDIAApiException">Status.NvidiaDeviceNotFound: No NVIDIA GPU driving a display was found.</exception>
/// <exception cref="Exception">A delegate callback throws an exception.</exception>
public static IClockFrequencies GetAllClockFrequencies(
PhysicalGPUHandle physicalGPUHandle,
IClockFrequencies clockFrequencyOptions = null)
{
var getClocksInfo = DelegateFactory.GetDelegate <Delegates.GPU.NvAPI_GPU_GetAllClockFrequencies>();
if (clockFrequencyOptions == null)
{
foreach (var acceptType in getClocksInfo.Accepts())
{
var instance = acceptType.Instantiate <IClockFrequencies>();
using (var clockFrequenciesInfo = ValueTypeReference.FromValueType(instance, acceptType))
{
var status = getClocksInfo(physicalGPUHandle, clockFrequenciesInfo);
if (status == Status.IncompatibleStructureVersion)
{
continue;
}
if (status != Status.Ok)
{
throw new NVIDIAApiException(status);
}
return(clockFrequenciesInfo.ToValueType <IClockFrequencies>(acceptType));
}
}
}
else
{
using (var clockFrequenciesInfo =
ValueTypeReference.FromValueType(clockFrequencyOptions, clockFrequencyOptions.GetType()))
{
var status = getClocksInfo(physicalGPUHandle, clockFrequenciesInfo);
if (status != Status.Ok)
{
throw new NVIDIAApiException(status);
}
return(clockFrequenciesInfo.ToValueType <IClockFrequencies>(clockFrequencyOptions.GetType()));
}
}
throw new NVIDIANotSupportedException("This operation is not supported.");
}
/// <summary>
/// Determines the set of available display modes for a given grid topology.
/// </summary>
/// <param name="gridTopology">The grid topology to use.</param>
/// <returns></returns>
/// <exception cref="NVIDIAApiException">Status.InvalidArgument: One or more arguments passed in are invalid.</exception>
/// <exception cref="NVIDIAApiException">Status.ApiNotInitialized: The NvAPI API needs to be initialized first.</exception>
/// <exception cref="NVIDIAApiException">Status.NoImplementation: This entry point not available.</exception>
/// <exception cref="NVIDIAApiException">Status.Error: Miscellaneous error occurred.</exception>
/// <exception cref="NVIDIANotSupportedException">This operation is not supported.</exception>
/// <exception cref="Exception">A delegate callback throws an exception.</exception>
public static IDisplaySettings[] EnumDisplayModes(IGridTopology gridTopology)
{
var mosaicEnumDisplayModes = DelegateFactory.GetDelegate <Delegates.Mosaic.NvAPI_Mosaic_EnumDisplayModes>();
using (var gridTopologyByRef = ValueTypeReference.FromValueType(gridTopology, gridTopology.GetType()))
{
var totalAvailable = 0u;
var status = mosaicEnumDisplayModes(gridTopologyByRef, ValueTypeArray.Null, ref totalAvailable);
if (status != Status.Ok)
{
throw new NVIDIAApiException(status);
}
if (totalAvailable == 0)
{
return(new IDisplaySettings[0]);
}
foreach (var acceptType in mosaicEnumDisplayModes.Accepts(2))
{
var counts = totalAvailable;
var instance = acceptType.Instantiate <IDisplaySettings>();
using (
var displaySettingByRef =
ValueTypeArray.FromArray(instance.Repeat((int)counts).AsEnumerable()))
{
status = mosaicEnumDisplayModes(gridTopologyByRef, displaySettingByRef, ref counts);
if (status == Status.IncompatibleStructureVersion)
{
continue;
}
if (status != Status.Ok)
{
throw new NVIDIAApiException(status);
}
return(displaySettingByRef.ToArray <IDisplaySettings>((int)counts, acceptType));
}
}
throw new NVIDIANotSupportedException("This operation is not supported.");
}
}
/// <summary>
/// [PRIVATE]
/// Sets the thermal policies status for the passed GPU handle.
/// </summary>
/// <param name="gpuHandle">The handle of the GPU to perform the operation on.</param>
/// <param name="thermalPoliciesStatus">The new thermal limiter policy to apply.</param>
public static void SetThermalPoliciesStatus(
PhysicalGPUHandle gpuHandle,
PrivateThermalPoliciesStatusV2 thermalPoliciesStatus)
{
using (var policiesStatusReference = ValueTypeReference.FromValueType(thermalPoliciesStatus))
{
var status = DelegateFactory.GetDelegate <Delegates.GPU.NvAPI_GPU_SetThermalPoliciesStatus>()(
gpuHandle,
policiesStatusReference
);
if (status != Status.Ok)
{
throw new NVIDIAApiException(status);
}
}
}
/// <summary>
/// [PRIVATE]
/// Gets additional information about the PCIe interface and configuration for the passed GPU handle.
/// </summary>
/// <param name="gpuHandle">The handle of the GPU to perform the operation on.</param>
/// <returns>PCIe information and configurations.</returns>
public static PrivatePCIeInfoV2 GetPCIEInfo(PhysicalGPUHandle gpuHandle)
{
var instance = typeof(PrivatePCIeInfoV2).Instantiate <PrivatePCIeInfoV2>();
using (var pcieInfoReference = ValueTypeReference.FromValueType(instance))
{
var status =
DelegateFactory.GetDelegate <Delegates.GPU.NvAPI_GPU_GetPCIEInfo>()(gpuHandle, pcieInfoReference);
if (status != Status.Ok)
{
throw new NVIDIAApiException(status);
}
return(pcieInfoReference.ToValueType <PrivatePCIeInfoV2>(typeof(PrivatePCIeInfoV2)));
}
}
/// <summary>
/// Sets the control information about illumination devices on the given GPU.
/// </summary>
/// <param name="gpuHandle">The physical GPU handle.</param>
/// <param name="deviceControlParameters">The new control illumination devices control information.</param>
public static void ClientIlluminationDevicesSetControl(
PhysicalGPUHandle gpuHandle,
IlluminationDeviceControlParametersV1 deviceControlParameters)
{
using (var deviceControlParametersReference = ValueTypeReference.FromValueType(deviceControlParameters))
{
var status = DelegateFactory.GetDelegate <Delegates.GPU.NvAPI_GPU_ClientIlluminationDevicesSetControl>()(
gpuHandle,
deviceControlParametersReference
);
if (status != Status.Ok)
{
throw new NVIDIAApiException(status);
}
}
}
