.TH "vGPU Management" 3 "24 Apr 2019" "Version 1.1" "NVML" \" -*- nroff -*-
.ad l
.nh
.SH NAME
vGPU Management \- 
.SS "Functions"

.in +1c
.ti -1c
.RI "\fBnvmlReturn_t\fP DECLDIR \fBnvmlDeviceGetSupportedVgpus\fP (nvmlDevice_t device, unsigned int *vgpuCount, nvmlVgpuTypeId_t *vgpuTypeIds)"
.br
.ti -1c
.RI "\fBnvmlReturn_t\fP DECLDIR \fBnvmlDeviceGetCreatableVgpus\fP (nvmlDevice_t device, unsigned int *vgpuCount, nvmlVgpuTypeId_t *vgpuTypeIds)"
.br
.ti -1c
.RI "\fBnvmlReturn_t\fP DECLDIR \fBnvmlVgpuTypeGetClass\fP (nvmlVgpuTypeId_t vgpuTypeId, char *vgpuTypeClass, unsigned int *size)"
.br
.ti -1c
.RI "\fBnvmlReturn_t\fP DECLDIR \fBnvmlVgpuTypeGetName\fP (nvmlVgpuTypeId_t vgpuTypeId, char *vgpuTypeName, unsigned int *size)"
.br
.ti -1c
.RI "\fBnvmlReturn_t\fP DECLDIR \fBnvmlVgpuTypeGetDeviceID\fP (nvmlVgpuTypeId_t vgpuTypeId, unsigned long long *deviceID, unsigned long long *subsystemID)"
.br
.ti -1c
.RI "\fBnvmlReturn_t\fP DECLDIR \fBnvmlVgpuTypeGetFramebufferSize\fP (nvmlVgpuTypeId_t vgpuTypeId, unsigned long long *fbSize)"
.br
.ti -1c
.RI "\fBnvmlReturn_t\fP DECLDIR \fBnvmlVgpuTypeGetNumDisplayHeads\fP (nvmlVgpuTypeId_t vgpuTypeId, unsigned int *numDisplayHeads)"
.br
.ti -1c
.RI "\fBnvmlReturn_t\fP DECLDIR \fBnvmlVgpuTypeGetResolution\fP (nvmlVgpuTypeId_t vgpuTypeId, unsigned int displayIndex, unsigned int *xdim, unsigned int *ydim)"
.br
.ti -1c
.RI "\fBnvmlReturn_t\fP DECLDIR \fBnvmlVgpuTypeGetLicense\fP (nvmlVgpuTypeId_t vgpuTypeId, char *vgpuTypeLicenseString, unsigned int size)"
.br
.ti -1c
.RI "\fBnvmlReturn_t\fP DECLDIR \fBnvmlVgpuTypeGetFrameRateLimit\fP (nvmlVgpuTypeId_t vgpuTypeId, unsigned int *frameRateLimit)"
.br
.ti -1c
.RI "\fBnvmlReturn_t\fP DECLDIR \fBnvmlVgpuTypeGetMaxInstances\fP (nvmlDevice_t device, nvmlVgpuTypeId_t vgpuTypeId, unsigned int *vgpuInstanceCount)"
.br
.ti -1c
.RI "\fBnvmlReturn_t\fP DECLDIR \fBnvmlVgpuTypeGetMaxInstancesPerVm\fP (nvmlVgpuTypeId_t vgpuTypeId, unsigned int *vgpuInstanceCountPerVm)"
.br
.ti -1c
.RI "\fBnvmlReturn_t\fP DECLDIR \fBnvmlDeviceGetActiveVgpus\fP (nvmlDevice_t device, unsigned int *vgpuCount, nvmlVgpuInstance_t *vgpuInstances)"
.br
.ti -1c
.RI "\fBnvmlReturn_t\fP DECLDIR \fBnvmlVgpuInstanceGetVmID\fP (nvmlVgpuInstance_t vgpuInstance, char *vmId, unsigned int size, \fBnvmlVgpuVmIdType_t\fP *vmIdType)"
.br
.ti -1c
.RI "\fBnvmlReturn_t\fP DECLDIR \fBnvmlVgpuInstanceGetUUID\fP (nvmlVgpuInstance_t vgpuInstance, char *uuid, unsigned int size)"
.br
.ti -1c
.RI "\fBnvmlReturn_t\fP DECLDIR \fBnvmlVgpuInstanceGetVmDriverVersion\fP (nvmlVgpuInstance_t vgpuInstance, char *version, unsigned int length)"
.br
.ti -1c
.RI "\fBnvmlReturn_t\fP DECLDIR \fBnvmlVgpuInstanceGetFbUsage\fP (nvmlVgpuInstance_t vgpuInstance, unsigned long long *fbUsage)"
.br
.ti -1c
.RI "\fBnvmlReturn_t\fP DECLDIR \fBnvmlVgpuInstanceGetLicenseStatus\fP (nvmlVgpuInstance_t vgpuInstance, unsigned int *licensed)"
.br
.ti -1c
.RI "\fBnvmlReturn_t\fP DECLDIR \fBnvmlVgpuInstanceGetType\fP (nvmlVgpuInstance_t vgpuInstance, nvmlVgpuTypeId_t *vgpuTypeId)"
.br
.ti -1c
.RI "\fBnvmlReturn_t\fP DECLDIR \fBnvmlVgpuInstanceGetFrameRateLimit\fP (nvmlVgpuInstance_t vgpuInstance, unsigned int *frameRateLimit)"
.br
.ti -1c
.RI "\fBnvmlReturn_t\fP DECLDIR \fBnvmlVgpuInstanceGetEncoderCapacity\fP (nvmlVgpuInstance_t vgpuInstance, unsigned int *encoderCapacity)"
.br
.ti -1c
.RI "\fBnvmlReturn_t\fP DECLDIR \fBnvmlVgpuInstanceSetEncoderCapacity\fP (nvmlVgpuInstance_t vgpuInstance, unsigned int encoderCapacity)"
.br
.ti -1c
.RI "\fBnvmlReturn_t\fP DECLDIR \fBnvmlDeviceGetVgpuUtilization\fP (nvmlDevice_t device, unsigned long long lastSeenTimeStamp, \fBnvmlValueType_t\fP *sampleValType, unsigned int *vgpuInstanceSamplesCount, \fBnvmlVgpuInstanceUtilizationSample_t\fP *utilizationSamples)"
.br
.ti -1c
.RI "\fBnvmlReturn_t\fP DECLDIR \fBnvmlDeviceGetVgpuProcessUtilization\fP (nvmlDevice_t device, unsigned long long lastSeenTimeStamp, unsigned int *vgpuProcessSamplesCount, \fBnvmlVgpuProcessUtilizationSample_t\fP *utilizationSamples)"
.br
.ti -1c
.RI "\fBnvmlReturn_t\fP DECLDIR \fBnvmlDeviceGetGridLicensableFeatures\fP (nvmlDevice_t device, \fBnvmlGridLicensableFeatures_t\fP *pGridLicensableFeatures)"
.br
.ti -1c
.RI "\fBnvmlReturn_t\fP DECLDIR \fBnvmlVgpuInstanceGetEncoderStats\fP (nvmlVgpuInstance_t vgpuInstance, unsigned int *sessionCount, unsigned int *averageFps, unsigned int *averageLatency)"
.br
.ti -1c
.RI "\fBnvmlReturn_t\fP DECLDIR \fBnvmlVgpuInstanceGetEncoderSessions\fP (nvmlVgpuInstance_t vgpuInstance, unsigned int *sessionCount, \fBnvmlEncoderSessionInfo_t\fP *sessionInfo)"
.br
.ti -1c
.RI "\fBnvmlReturn_t\fP DECLDIR \fBnvmlVgpuInstanceGetFBCStats\fP (nvmlVgpuInstance_t vgpuInstance, \fBnvmlFBCStats_t\fP *fbcStats)"
.br
.ti -1c
.RI "\fBnvmlReturn_t\fP DECLDIR \fBnvmlVgpuInstanceGetFBCSessions\fP (nvmlVgpuInstance_t vgpuInstance, unsigned int *sessionCount, \fBnvmlFBCSessionInfo_t\fP *sessionInfo)"
.br
.ti -1c
.RI "\fBnvmlReturn_t\fP DECLDIR \fBnvmlDeviceGetProcessUtilization\fP (nvmlDevice_t device, \fBnvmlProcessUtilizationSample_t\fP *utilization, unsigned int *processSamplesCount, unsigned long long lastSeenTimeStamp)"
.br
.ti -1c
.RI "\fBnvmlReturn_t\fP DECLDIR \fBnvmlVgpuInstanceGetAccountingMode\fP (nvmlVgpuInstance_t vgpuInstance, \fBnvmlEnableState_t\fP *mode)"
.br
.ti -1c
.RI "\fBnvmlReturn_t\fP DECLDIR \fBnvmlVgpuInstanceGetAccountingPids\fP (nvmlVgpuInstance_t vgpuInstance, unsigned int *count, unsigned int *pids)"
.br
.ti -1c
.RI "\fBnvmlReturn_t\fP DECLDIR \fBnvmlVgpuInstanceGetAccountingStats\fP (nvmlVgpuInstance_t vgpuInstance, unsigned int pid, \fBnvmlAccountingStats_t\fP *stats)"
.br
.in -1c
.SH "Detailed Description"
.PP 
Set of APIs supporting GRID vGPU 
.SH "Function Documentation"
.PP 
.SS "\fBnvmlReturn_t\fP DECLDIR nvmlDeviceGetActiveVgpus (nvmlDevice_t device, unsigned int * vgpuCount, nvmlVgpuInstance_t * vgpuInstances)"
.PP
Retrieve the active vGPU instances on a device.
.PP
An array of active vGPU instances is returned in the caller-supplied buffer pointed at by \fIvgpuInstances\fP. The array elememt count is passed in \fIvgpuCount\fP, and \fIvgpuCount\fP is used to return the number of vGPU instances written to the buffer.
.PP
If the supplied buffer is not large enough to accomodate the vGPU instance array, the function returns NVML_ERROR_INSUFFICIENT_SIZE, with the element count of nvmlVgpuInstance_t array required in \fIvgpuCount\fP. To query the number of active vGPU instances, call this function with *vgpuCount = 0. The code will return NVML_ERROR_INSUFFICIENT_SIZE, or NVML_SUCCESS if no vGPU Types are supported.
.PP
For Kepler (TM) or newer fully supported devices.
.PP
\fBParameters:\fP
.RS 4
\fIdevice\fP The identifier of the target device 
.br
\fIvgpuCount\fP Pointer which passes in the array size as well as get back the number of types 
.br
\fIvgpuInstances\fP Pointer to array in which to return list of vGPU instances
.RE
.PP
\fBReturns:\fP
.RS 4
.IP "\(bu" 2
\fBNVML_SUCCESS\fP successful completion
.IP "\(bu" 2
\fBNVML_ERROR_UNINITIALIZED\fP if the library has not been successfully initialized
.IP "\(bu" 2
\fBNVML_ERROR_INVALID_ARGUMENT\fP if \fIdevice\fP is invalid, or \fIvgpuCount\fP is NULL
.IP "\(bu" 2
\fBNVML_ERROR_INSUFFICIENT_SIZE\fP if \fIsize\fP is too small
.IP "\(bu" 2
\fBNVML_ERROR_NOT_SUPPORTED\fP if vGPU is not supported by the device
.IP "\(bu" 2
\fBNVML_ERROR_UNKNOWN\fP on any unexpected error 
.PP
.RE
.PP

.SS "\fBnvmlReturn_t\fP DECLDIR nvmlDeviceGetCreatableVgpus (nvmlDevice_t device, unsigned int * vgpuCount, nvmlVgpuTypeId_t * vgpuTypeIds)"
.PP
Retrieve the currently creatable vGPU types on a physical GPU (device).
.PP
An array of creatable vGPU types for the physical GPU indicated by \fIdevice\fP is returned in the caller-supplied buffer pointed at by \fIvgpuTypeIds\fP. The element count of nvmlVgpuTypeId_t array is passed in \fIvgpuCount\fP, and \fIvgpuCount\fP is used to return the number of vGPU types written to the buffer.
.PP
The creatable vGPU types for a device may differ over time, as there may be restrictions on what type of vGPU types can concurrently run on a device. For example, if only one vGPU type is allowed at a time on a device, then the creatable list will be restricted to whatever vGPU type is already running on the device.
.PP
If the supplied buffer is not large enough to accomodate the vGPU type array, the function returns NVML_ERROR_INSUFFICIENT_SIZE, with the element count of nvmlVgpuTypeId_t array required in \fIvgpuCount\fP. To query the number of vGPU types createable for the GPU, call this function with *vgpuCount = 0. The code will return NVML_ERROR_INSUFFICIENT_SIZE, or NVML_SUCCESS if no vGPU types are creatable.
.PP
\fBParameters:\fP
.RS 4
\fIdevice\fP The identifier of the target device 
.br
\fIvgpuCount\fP Pointer to caller-supplied array size, and returns number of vGPU types 
.br
\fIvgpuTypeIds\fP Pointer to caller-supplied array in which to return list of vGPU types
.RE
.PP
\fBReturns:\fP
.RS 4
.IP "\(bu" 2
\fBNVML_SUCCESS\fP successful completion
.IP "\(bu" 2
\fBNVML_ERROR_INSUFFICIENT_SIZE\fP \fIvgpuTypeIds\fP buffer is too small, array element count is returned in \fIvgpuCount\fP 
.IP "\(bu" 2
\fBNVML_ERROR_INVALID_ARGUMENT\fP if \fIvgpuCount\fP is NULL
.IP "\(bu" 2
\fBNVML_ERROR_NOT_SUPPORTED\fP if vGPU is not supported by the device
.IP "\(bu" 2
\fBNVML_ERROR_VGPU_ECC_NOT_SUPPORTED\fP if ECC is enabled on the device
.IP "\(bu" 2
\fBNVML_ERROR_UNKNOWN\fP on any unexpected error 
.PP
.RE
.PP

.SS "\fBnvmlReturn_t\fP DECLDIR nvmlDeviceGetGridLicensableFeatures (nvmlDevice_t device, \fBnvmlGridLicensableFeatures_t\fP * pGridLicensableFeatures)"
.PP
Retrieve the GRID licensable features.
.PP
Identifies whether the system supports GRID Software Licensing. If it does, return the list of licensable feature(s) and their current license status.
.PP
\fBParameters:\fP
.RS 4
\fIdevice\fP Identifier of the target device 
.br
\fIpGridLicensableFeatures\fP Pointer to structure in which GRID licensable features are returned
.RE
.PP
\fBReturns:\fP
.RS 4
.IP "\(bu" 2
\fBNVML_SUCCESS\fP if licensable features are successfully retrieved
.IP "\(bu" 2
\fBNVML_ERROR_INVALID_ARGUMENT\fP if \fIpGridLicensableFeatures\fP is NULL
.IP "\(bu" 2
\fBNVML_ERROR_UNKNOWN\fP on any unexpected error 
.PP
.RE
.PP

.SS "\fBnvmlReturn_t\fP DECLDIR nvmlDeviceGetProcessUtilization (nvmlDevice_t device, \fBnvmlProcessUtilizationSample_t\fP * utilization, unsigned int * processSamplesCount, unsigned long long lastSeenTimeStamp)"
.PP
Retrieves the current utilization and process ID
.PP
For Maxwell (TM) or newer fully supported devices.
.PP
Reads recent utilization of GPU SM (3D/Compute), framebuffer, video encoder, and video decoder for processes running. Utilization values are returned as an array of utilization sample structures in the caller-supplied buffer pointed at by \fIutilization\fP. One utilization sample structure is returned per process running, that had some non-zero utilization during the last sample period. It includes the CPU timestamp at which the samples were recorded. Individual utilization values are returned as 'unsigned int' values.
.PP
To read utilization values, first determine the size of buffer required to hold the samples by invoking the function with \fIutilization\fP set to NULL. The caller should allocate a buffer of size processSamplesCount * sizeof(nvmlProcessUtilizationSample_t). Invoke the function again with the allocated buffer passed in \fIutilization\fP, and \fIprocessSamplesCount\fP set to the number of entries the buffer is sized for.
.PP
On successful return, the function updates \fIprocessSamplesCount\fP with the number of process utilization sample structures that were actually written. This may differ from a previously read value as instances are created or destroyed.
.PP
lastSeenTimeStamp represents the CPU timestamp in microseconds at which utilization samples were last read. Set it to 0 to read utilization based on all the samples maintained by the driver's internal sample buffer. Set lastSeenTimeStamp to a timeStamp retrieved from a previous query to read utilization since the previous query.
.PP
\fBParameters:\fP
.RS 4
\fIdevice\fP The identifier of the target device 
.br
\fIutilization\fP Pointer to caller-supplied buffer in which guest process utilization samples are returned 
.br
\fIprocessSamplesCount\fP Pointer to caller-supplied array size, and returns number of processes running 
.br
\fIlastSeenTimeStamp\fP Return only samples with timestamp greater than lastSeenTimeStamp.
.RE
.PP
\fBReturns:\fP
.RS 4
.IP "\(bu" 2
\fBNVML_SUCCESS\fP if \fIutilization\fP has been populated
.IP "\(bu" 2
\fBNVML_ERROR_UNINITIALIZED\fP if the library has not been successfully initialized
.IP "\(bu" 2
\fBNVML_ERROR_INVALID_ARGUMENT\fP if \fIdevice\fP is invalid, \fIutilization\fP is NULL, or \fIsamplingPeriodUs\fP is NULL
.IP "\(bu" 2
\fBNVML_ERROR_NOT_SUPPORTED\fP if the device does not support this feature
.IP "\(bu" 2
\fBNVML_ERROR_GPU_IS_LOST\fP if the target GPU has fallen off the bus or is otherwise inaccessible
.IP "\(bu" 2
\fBNVML_ERROR_UNKNOWN\fP on any unexpected error 
.PP
.RE
.PP

.SS "\fBnvmlReturn_t\fP DECLDIR nvmlDeviceGetSupportedVgpus (nvmlDevice_t device, unsigned int * vgpuCount, nvmlVgpuTypeId_t * vgpuTypeIds)"
.PP
Retrieve the supported vGPU types on a physical GPU (device).
.PP
An array of supported vGPU types for the physical GPU indicated by \fIdevice\fP is returned in the caller-supplied buffer pointed at by \fIvgpuTypeIds\fP. The element count of nvmlVgpuTypeId_t array is passed in \fIvgpuCount\fP, and \fIvgpuCount\fP is used to return the number of vGPU types written to the buffer.
.PP
If the supplied buffer is not large enough to accomodate the vGPU type array, the function returns NVML_ERROR_INSUFFICIENT_SIZE, with the element count of nvmlVgpuTypeId_t array required in \fIvgpuCount\fP. To query the number of vGPU types supported for the GPU, call this function with *vgpuCount = 0. The code will return NVML_ERROR_INSUFFICIENT_SIZE, or NVML_SUCCESS if no vGPU types are supported.
.PP
\fBParameters:\fP
.RS 4
\fIdevice\fP The identifier of the target device 
.br
\fIvgpuCount\fP Pointer to caller-supplied array size, and returns number of vGPU types 
.br
\fIvgpuTypeIds\fP Pointer to caller-supplied array in which to return list of vGPU types
.RE
.PP
\fBReturns:\fP
.RS 4
.IP "\(bu" 2
\fBNVML_SUCCESS\fP successful completion
.IP "\(bu" 2
\fBNVML_ERROR_INSUFFICIENT_SIZE\fP \fIvgpuTypeIds\fP buffer is too small, array element count is returned in \fIvgpuCount\fP 
.IP "\(bu" 2
\fBNVML_ERROR_INVALID_ARGUMENT\fP if \fIvgpuCount\fP is NULL or \fIdevice\fP is invalid
.IP "\(bu" 2
\fBNVML_ERROR_NOT_SUPPORTED\fP if vGPU is not supported by the device
.IP "\(bu" 2
\fBNVML_ERROR_VGPU_ECC_NOT_SUPPORTED\fP if ECC is enabled on the device
.IP "\(bu" 2
\fBNVML_ERROR_UNKNOWN\fP on any unexpected error 
.PP
.RE
.PP

.SS "\fBnvmlReturn_t\fP DECLDIR nvmlDeviceGetVgpuProcessUtilization (nvmlDevice_t device, unsigned long long lastSeenTimeStamp, unsigned int * vgpuProcessSamplesCount, \fBnvmlVgpuProcessUtilizationSample_t\fP * utilizationSamples)"
.PP
Retrieves current utilization for processes running on vGPUs on a physical GPU (device).
.PP
For Maxwell (TM) or newer fully supported devices.
.PP
Reads recent utilization of GPU SM (3D/Compute), framebuffer, video encoder, and video decoder for processes running on vGPU instances active on a device. Utilization values are returned as an array of utilization sample structures in the caller-supplied buffer pointed at by \fIutilizationSamples\fP. One utilization sample structure is returned per process running on vGPU instances, that had some non-zero utilization during the last sample period. It includes the CPU timestamp at which the samples were recorded. Individual utilization values are returned as 'unsigned int' values.
.PP
To read utilization values, first determine the size of buffer required to hold the samples by invoking the function with \fIutilizationSamples\fP set to NULL. The function will return NVML_ERROR_INSUFFICIENT_SIZE, with the current vGPU instance count in \fIvgpuProcessSamplesCount\fP. The caller should allocate a buffer of size vgpuProcessSamplesCount * sizeof(nvmlVgpuProcessUtilizationSample_t). Invoke the function again with the allocated buffer passed in \fIutilizationSamples\fP, and \fIvgpuProcessSamplesCount\fP set to the number of entries the buffer is sized for.
.PP
On successful return, the function updates \fIvgpuSubProcessSampleCount\fP with the number of vGPU sub process utilization sample structures that were actually written. This may differ from a previously read value depending on the number of processes that are active in any given sample period.
.PP
lastSeenTimeStamp represents the CPU timestamp in microseconds at which utilization samples were last read. Set it to 0 to read utilization based on all the samples maintained by the driver's internal sample buffer. Set lastSeenTimeStamp to a timeStamp retrieved from a previous query to read utilization since the previous query.
.PP
\fBParameters:\fP
.RS 4
\fIdevice\fP The identifier for the target device 
.br
\fIlastSeenTimeStamp\fP Return only samples with timestamp greater than lastSeenTimeStamp. 
.br
\fIvgpuProcessSamplesCount\fP Pointer to caller-supplied array size, and returns number of processes running on vGPU instances 
.br
\fIutilizationSamples\fP Pointer to caller-supplied buffer in which vGPU sub process utilization samples are returned
.RE
.PP
\fBReturns:\fP
.RS 4
.IP "\(bu" 2
\fBNVML_SUCCESS\fP if utilization samples are successfully retrieved
.IP "\(bu" 2
\fBNVML_ERROR_UNINITIALIZED\fP if the library has not been successfully initialized
.IP "\(bu" 2
\fBNVML_ERROR_INVALID_ARGUMENT\fP if \fIdevice\fP is invalid, \fIvgpuProcessSamplesCount\fP or a sample count of 0 is passed with a non-NULL \fIutilizationSamples\fP 
.IP "\(bu" 2
\fBNVML_ERROR_INSUFFICIENT_SIZE\fP if supplied \fIvgpuProcessSamplesCount\fP is too small to return samples for all vGPU instances currently executing on the device
.IP "\(bu" 2
\fBNVML_ERROR_NOT_SUPPORTED\fP if vGPU is not supported by the device
.IP "\(bu" 2
\fBNVML_ERROR_GPU_IS_LOST\fP if the target GPU has fallen off the bus or is otherwise inaccessible
.IP "\(bu" 2
\fBNVML_ERROR_NOT_FOUND\fP if sample entries are not found
.IP "\(bu" 2
\fBNVML_ERROR_UNKNOWN\fP on any unexpected error 
.PP
.RE
.PP

.SS "\fBnvmlReturn_t\fP DECLDIR nvmlDeviceGetVgpuUtilization (nvmlDevice_t device, unsigned long long lastSeenTimeStamp, \fBnvmlValueType_t\fP * sampleValType, unsigned int * vgpuInstanceSamplesCount, \fBnvmlVgpuInstanceUtilizationSample_t\fP * utilizationSamples)"
.PP
Retrieves current utilization for vGPUs on a physical GPU (device).
.PP
For Kepler (TM) or newer fully supported devices.
.PP
Reads recent utilization of GPU SM (3D/Compute), framebuffer, video encoder, and video decoder for vGPU instances running on a device. Utilization values are returned as an array of utilization sample structures in the caller-supplied buffer pointed at by \fIutilizationSamples\fP. One utilization sample structure is returned per vGPU instance, and includes the CPU timestamp at which the samples were recorded. Individual utilization values are returned as 'unsigned int' values in \fBnvmlValue_t\fP unions. The function sets the caller-supplied \fIsampleValType\fP to NVML_VALUE_TYPE_UNSIGNED_INT to indicate the returned value type.
.PP
To read utilization values, first determine the size of buffer required to hold the samples by invoking the function with \fIutilizationSamples\fP set to NULL. The function will return NVML_ERROR_INSUFFICIENT_SIZE, with the current vGPU instance count in \fIvgpuInstanceSamplesCount\fP, or NVML_SUCCESS if the current vGPU instance count is zero. The caller should allocate a buffer of size vgpuInstanceSamplesCount * sizeof(nvmlVgpuInstanceUtilizationSample_t). Invoke the function again with the allocated buffer passed in \fIutilizationSamples\fP, and \fIvgpuInstanceSamplesCount\fP set to the number of entries the buffer is sized for.
.PP
On successful return, the function updates \fIvgpuInstanceSampleCount\fP with the number of vGPU utilization sample structures that were actually written. This may differ from a previously read value as vGPU instances are created or destroyed.
.PP
lastSeenTimeStamp represents the CPU timestamp in microseconds at which utilization samples were last read. Set it to 0 to read utilization based on all the samples maintained by the driver's internal sample buffer. Set lastSeenTimeStamp to a timeStamp retrieved from a previous query to read utilization since the previous query.
.PP
\fBParameters:\fP
.RS 4
\fIdevice\fP The identifier for the target device 
.br
\fIlastSeenTimeStamp\fP Return only samples with timestamp greater than lastSeenTimeStamp. 
.br
\fIsampleValType\fP Pointer to caller-supplied buffer to hold the type of returned sample values 
.br
\fIvgpuInstanceSamplesCount\fP Pointer to caller-supplied array size, and returns number of vGPU instances 
.br
\fIutilizationSamples\fP Pointer to caller-supplied buffer in which vGPU utilization samples are returned
.RE
.PP
\fBReturns:\fP
.RS 4
.IP "\(bu" 2
\fBNVML_SUCCESS\fP if utilization samples are successfully retrieved
.IP "\(bu" 2
\fBNVML_ERROR_UNINITIALIZED\fP if the library has not been successfully initialized
.IP "\(bu" 2
\fBNVML_ERROR_INVALID_ARGUMENT\fP if \fIdevice\fP is invalid, \fIvgpuInstanceSamplesCount\fP or \fIsampleValType\fP is NULL, or a sample count of 0 is passed with a non-NULL \fIutilizationSamples\fP 
.IP "\(bu" 2
\fBNVML_ERROR_INSUFFICIENT_SIZE\fP if supplied \fIvgpuInstanceSamplesCount\fP is too small to return samples for all vGPU instances currently executing on the device
.IP "\(bu" 2
\fBNVML_ERROR_NOT_SUPPORTED\fP if vGPU is not supported by the device
.IP "\(bu" 2
\fBNVML_ERROR_GPU_IS_LOST\fP if the target GPU has fallen off the bus or is otherwise inaccessible
.IP "\(bu" 2
\fBNVML_ERROR_NOT_FOUND\fP if sample entries are not found
.IP "\(bu" 2
\fBNVML_ERROR_UNKNOWN\fP on any unexpected error 
.PP
.RE
.PP

.SS "\fBnvmlReturn_t\fP DECLDIR nvmlVgpuInstanceGetAccountingMode (nvmlVgpuInstance_t vgpuInstance, \fBnvmlEnableState_t\fP * mode)"
.PP
Queries the state of per process accounting mode on vGPU.
.PP
For Maxwell (TM) or newer fully supported devices.
.PP
\fBParameters:\fP
.RS 4
\fIvgpuInstance\fP The identifier of the target vGPU VM 
.br
\fImode\fP Reference in which to return the current accounting mode
.RE
.PP
\fBReturns:\fP
.RS 4
.IP "\(bu" 2
\fBNVML_SUCCESS\fP if the mode has been successfully retrieved
.IP "\(bu" 2
\fBNVML_ERROR_UNINITIALIZED\fP if the library has not been successfully initialized
.IP "\(bu" 2
\fBNVML_ERROR_INVALID_ARGUMENT\fP if \fIvgpuInstance\fP is 0, or \fImode\fP is NULL
.IP "\(bu" 2
\fBNVML_ERROR_NOT_FOUND\fP if \fIvgpuInstance\fP does not match a valid active vGPU instance on the system
.IP "\(bu" 2
\fBNVML_ERROR_NOT_SUPPORTED\fP if the vGPU doesn't support this feature
.IP "\(bu" 2
\fBNVML_ERROR_UNKNOWN\fP on any unexpected error 
.PP
.RE
.PP

.SS "\fBnvmlReturn_t\fP DECLDIR nvmlVgpuInstanceGetAccountingPids (nvmlVgpuInstance_t vgpuInstance, unsigned int * count, unsigned int * pids)"
.PP
Queries list of processes running on vGPU that can be queried for accounting stats. The list of processes returned can be in running or terminated state.
.PP
For Maxwell (TM) or newer fully supported devices.
.PP
To just query the maximum number of processes that can be queried, call this function with *count = 0 and pids=NULL. The return code will be NVML_ERROR_INSUFFICIENT_SIZE, or NVML_SUCCESS if list is empty.
.PP
For more details see \fBnvmlVgpuInstanceGetAccountingStats\fP.
.PP
\fBNote:\fP
.RS 4
In case of PID collision some processes might not be accessible before the circular buffer is full.
.RE
.PP
\fBParameters:\fP
.RS 4
\fIvgpuInstance\fP The identifier of the target vGPU VM 
.br
\fIcount\fP Reference in which to provide the \fIpids\fP array size, and to return the number of elements ready to be queried 
.br
\fIpids\fP Reference in which to return list of process ids
.RE
.PP
\fBReturns:\fP
.RS 4
.IP "\(bu" 2
\fBNVML_SUCCESS\fP if pids were successfully retrieved
.IP "\(bu" 2
\fBNVML_ERROR_UNINITIALIZED\fP if the library has not been successfully initialized
.IP "\(bu" 2
\fBNVML_ERROR_INVALID_ARGUMENT\fP if \fIvgpuInstance\fP is 0, or \fIcount\fP is NULL
.IP "\(bu" 2
\fBNVML_ERROR_NOT_FOUND\fP if \fIvgpuInstance\fP does not match a valid active vGPU instance on the system
.IP "\(bu" 2
\fBNVML_ERROR_NOT_SUPPORTED\fP if the vGPU doesn't support this feature or accounting mode is disabled
.IP "\(bu" 2
\fBNVML_ERROR_INSUFFICIENT_SIZE\fP if \fIcount\fP is too small (\fIcount\fP is set to expected value)
.IP "\(bu" 2
\fBNVML_ERROR_UNKNOWN\fP on any unexpected error
.PP
.RE
.PP
\fBSee also:\fP
.RS 4
\fBnvmlVgpuInstanceGetAccountingPids\fP 
.RE
.PP

.SS "\fBnvmlReturn_t\fP DECLDIR nvmlVgpuInstanceGetAccountingStats (nvmlVgpuInstance_t vgpuInstance, unsigned int pid, \fBnvmlAccountingStats_t\fP * stats)"
.PP
Queries process's accounting stats.
.PP
For Maxwell (TM) or newer fully supported devices.
.PP
Accounting stats capture GPU utilization and other statistics across the lifetime of a process, and can be queried during life time of the process or after its termination. The time field in \fBnvmlAccountingStats_t\fP is reported as 0 during the lifetime of the process and updated to actual running time after its termination. Accounting stats are kept in a circular buffer, newly created processes overwrite information about old processes.
.PP
See \fBnvmlAccountingStats_t\fP for description of each returned metric. List of processes that can be queried can be retrieved from \fBnvmlVgpuInstanceGetAccountingPids\fP.
.PP
\fBNote:\fP
.RS 4
Accounting Mode needs to be on. See \fBnvmlVgpuInstanceGetAccountingMode\fP. 
.PP
Only compute and graphics applications stats can be queried. Monitoring applications stats can't be queried since they don't contribute to GPU utilization. 
.PP
In case of pid collision stats of only the latest process (that terminated last) will be reported
.RE
.PP
\fBParameters:\fP
.RS 4
\fIvgpuInstance\fP The identifier of the target vGPU VM 
.br
\fIpid\fP Process Id of the target process to query stats for 
.br
\fIstats\fP Reference in which to return the process's accounting stats
.RE
.PP
\fBReturns:\fP
.RS 4
.IP "\(bu" 2
\fBNVML_SUCCESS\fP if stats have been successfully retrieved
.IP "\(bu" 2
\fBNVML_ERROR_UNINITIALIZED\fP if the library has not been successfully initialized
.IP "\(bu" 2
\fBNVML_ERROR_INVALID_ARGUMENT\fP if \fIvgpuInstance\fP is 0, or \fIstats\fP is NULL
.IP "\(bu" 2
\fBNVML_ERROR_NOT_FOUND\fP if \fIvgpuInstance\fP does not match a valid active vGPU instance on the system or \fIstats\fP is not found
.IP "\(bu" 2
\fBNVML_ERROR_NOT_SUPPORTED\fP if the vGPU doesn't support this feature or accounting mode is disabled
.IP "\(bu" 2
\fBNVML_ERROR_UNKNOWN\fP on any unexpected error 
.PP
.RE
.PP

.SS "\fBnvmlReturn_t\fP DECLDIR nvmlVgpuInstanceGetEncoderCapacity (nvmlVgpuInstance_t vgpuInstance, unsigned int * encoderCapacity)"
.PP
Retrieve the encoder capacity of a vGPU instance, as a percentage of maximum encoder capacity with valid values in the range 0-100.
.PP
For Maxwell (TM) or newer fully supported devices.
.PP
\fBParameters:\fP
.RS 4
\fIvgpuInstance\fP Identifier of the target vGPU instance 
.br
\fIencoderCapacity\fP Reference to an unsigned int for the encoder capacity
.RE
.PP
\fBReturns:\fP
.RS 4
.IP "\(bu" 2
\fBNVML_SUCCESS\fP if \fIencoderCapacity\fP has been retrived
.IP "\(bu" 2
\fBNVML_ERROR_UNINITIALIZED\fP if the library has not been successfully initialized
.IP "\(bu" 2
\fBNVML_ERROR_INVALID_ARGUMENT\fP if \fIvgpuInstance\fP is 0, or \fIencoderQueryType\fP is invalid
.IP "\(bu" 2
\fBNVML_ERROR_NOT_FOUND\fP if \fIvgpuInstance\fP does not match a valid active vGPU instance on the system
.IP "\(bu" 2
\fBNVML_ERROR_UNKNOWN\fP on any unexpected error 
.PP
.RE
.PP

.SS "\fBnvmlReturn_t\fP DECLDIR nvmlVgpuInstanceGetEncoderSessions (nvmlVgpuInstance_t vgpuInstance, unsigned int * sessionCount, \fBnvmlEncoderSessionInfo_t\fP * sessionInfo)"
.PP
Retrieves information about all active encoder sessions on a vGPU Instance.
.PP
An array of active encoder sessions is returned in the caller-supplied buffer pointed at by \fIsessionInfo\fP. The array element count is passed in \fIsessionCount\fP, and \fIsessionCount\fP is used to return the number of sessions written to the buffer.
.PP
If the supplied buffer is not large enough to accomodate the active session array, the function returns NVML_ERROR_INSUFFICIENT_SIZE, with the element count of \fBnvmlEncoderSessionInfo_t\fP array required in \fIsessionCount\fP. To query the number of active encoder sessions, call this function with *sessionCount = 0. The code will return NVML_SUCCESS with number of active encoder sessions updated in *sessionCount.
.PP
For Maxwell (TM) or newer fully supported devices.
.PP
\fBParameters:\fP
.RS 4
\fIvgpuInstance\fP Identifier of the target vGPU instance 
.br
\fIsessionCount\fP Reference to caller supplied array size, and returns the number of sessions. 
.br
\fIsessionInfo\fP Reference to caller supplied array in which the list of session information us returned.
.RE
.PP
\fBReturns:\fP
.RS 4
.IP "\(bu" 2
\fBNVML_SUCCESS\fP if \fIsessionInfo\fP is fetched
.IP "\(bu" 2
\fBNVML_ERROR_UNINITIALIZED\fP if the library has not been successfully initialized
.IP "\(bu" 2
\fBNVML_ERROR_INSUFFICIENT_SIZE\fP if \fIsessionCount\fP is too small, array element count is returned in \fIsessionCount\fP 
.IP "\(bu" 2
\fBNVML_ERROR_INVALID_ARGUMENT\fP if \fIsessionCount\fP is NULL, or \fIvgpuInstance\fP is 0.
.IP "\(bu" 2
\fBNVML_ERROR_NOT_FOUND\fP if \fIvgpuInstance\fP does not match a valid active vGPU instance on the system
.IP "\(bu" 2
\fBNVML_ERROR_UNKNOWN\fP on any unexpected error 
.PP
.RE
.PP

.SS "\fBnvmlReturn_t\fP DECLDIR nvmlVgpuInstanceGetEncoderStats (nvmlVgpuInstance_t vgpuInstance, unsigned int * sessionCount, unsigned int * averageFps, unsigned int * averageLatency)"
.PP
Retrieves the current encoder statistics of a vGPU Instance
.PP
For Maxwell (TM) or newer fully supported devices.
.PP
\fBParameters:\fP
.RS 4
\fIvgpuInstance\fP Identifier of the target vGPU instance 
.br
\fIsessionCount\fP Reference to an unsigned int for count of active encoder sessions 
.br
\fIaverageFps\fP Reference to an unsigned int for trailing average FPS of all active sessions 
.br
\fIaverageLatency\fP Reference to an unsigned int for encode latency in microseconds
.RE
.PP
\fBReturns:\fP
.RS 4
.IP "\(bu" 2
\fBNVML_SUCCESS\fP if \fIsessionCount\fP, \fIaverageFps\fP and \fIaverageLatency\fP is fetched
.IP "\(bu" 2
\fBNVML_ERROR_UNINITIALIZED\fP if the library has not been successfully initialized
.IP "\(bu" 2
\fBNVML_ERROR_INVALID_ARGUMENT\fP if \fIsessionCount\fP , or \fIaverageFps\fP or \fIaverageLatency\fP is NULL or \fIvgpuInstance\fP is 0.
.IP "\(bu" 2
\fBNVML_ERROR_NOT_FOUND\fP if \fIvgpuInstance\fP does not match a valid active vGPU instance on the system
.IP "\(bu" 2
\fBNVML_ERROR_UNKNOWN\fP on any unexpected error 
.PP
.RE
.PP

.SS "\fBnvmlReturn_t\fP DECLDIR nvmlVgpuInstanceGetFBCSessions (nvmlVgpuInstance_t vgpuInstance, unsigned int * sessionCount, \fBnvmlFBCSessionInfo_t\fP * sessionInfo)"
.PP
Retrieves information about active frame buffer capture sessions on a vGPU Instance.
.PP
An array of active FBC sessions is returned in the caller-supplied buffer pointed at by \fIsessionInfo\fP. The array element count is passed in \fIsessionCount\fP, and \fIsessionCount\fP is used to return the number of sessions written to the buffer.
.PP
If the supplied buffer is not large enough to accomodate the active session array, the function returns NVML_ERROR_INSUFFICIENT_SIZE, with the element count of \fBnvmlFBCSessionInfo_t\fP array required in \fIsessionCount\fP. To query the number of active FBC sessions, call this function with *sessionCount = 0. The code will return NVML_SUCCESS with number of active FBC sessions updated in *sessionCount.
.PP
For Maxwell (TM) or newer fully supported devices.
.PP
\fBNote:\fP
.RS 4
hResolution, vResolution, averageFPS and averageLatency data for a FBC session returned in \fIsessionInfo\fP may be zero if there are no new frames captured since the session started.
.RE
.PP
\fBParameters:\fP
.RS 4
\fIvgpuInstance\fP Identifier of the target vGPU instance 
.br
\fIsessionCount\fP Reference to caller supplied array size, and returns the number of sessions. 
.br
\fIsessionInfo\fP Reference in which to return the session information
.RE
.PP
\fBReturns:\fP
.RS 4
.IP "\(bu" 2
\fBNVML_SUCCESS\fP if \fIsessionInfo\fP is fetched
.IP "\(bu" 2
\fBNVML_ERROR_UNINITIALIZED\fP if the library has not been successfully initialized
.IP "\(bu" 2
\fBNVML_ERROR_INVALID_ARGUMENT\fP if \fIvgpuInstance\fP is 0, or \fIsessionCount\fP is NULL.
.IP "\(bu" 2
\fBNVML_ERROR_NOT_FOUND\fP if \fIvgpuInstance\fP does not match a valid active vGPU instance on the system
.IP "\(bu" 2
\fBNVML_ERROR_INSUFFICIENT_SIZE\fP if \fIsessionCount\fP is too small, array element count is returned in \fIsessionCount\fP 
.IP "\(bu" 2
\fBNVML_ERROR_UNKNOWN\fP on any unexpected error 
.PP
.RE
.PP

.SS "\fBnvmlReturn_t\fP DECLDIR nvmlVgpuInstanceGetFBCStats (nvmlVgpuInstance_t vgpuInstance, \fBnvmlFBCStats_t\fP * fbcStats)"
.PP
Retrieves the active frame buffer capture sessions statistics of a vGPU Instance
.PP
For Maxwell (TM) or newer fully supported devices.
.PP
\fBParameters:\fP
.RS 4
\fIvgpuInstance\fP Identifier of the target vGPU instance 
.br
\fIfbcStats\fP Reference to \fBnvmlFBCStats_t\fP structure contianing NvFBC stats
.RE
.PP
\fBReturns:\fP
.RS 4
.IP "\(bu" 2
\fBNVML_SUCCESS\fP if \fIfbcStats\fP is fetched
.IP "\(bu" 2
\fBNVML_ERROR_UNINITIALIZED\fP if the library has not been successfully initialized
.IP "\(bu" 2
\fBNVML_ERROR_INVALID_ARGUMENT\fP if \fIvgpuInstance\fP is 0, or \fIfbcStats\fP is NULL
.IP "\(bu" 2
\fBNVML_ERROR_NOT_FOUND\fP if \fIvgpuInstance\fP does not match a valid active vGPU instance on the system
.IP "\(bu" 2
\fBNVML_ERROR_UNKNOWN\fP on any unexpected error 
.PP
.RE
.PP

.SS "\fBnvmlReturn_t\fP DECLDIR nvmlVgpuInstanceGetFbUsage (nvmlVgpuInstance_t vgpuInstance, unsigned long long * fbUsage)"
.PP
Retrieve the framebuffer usage in bytes.
.PP
Framebuffer usage is the amont of vGPU framebuffer memory that is currently in use by the VM.
.PP
For Kepler (TM) or newer fully supported devices.
.PP
\fBParameters:\fP
.RS 4
\fIvgpuInstance\fP The identifier of the target instance 
.br
\fIfbUsage\fP Pointer to framebuffer usage in bytes
.RE
.PP
\fBReturns:\fP
.RS 4
.IP "\(bu" 2
\fBNVML_SUCCESS\fP successful completion
.IP "\(bu" 2
\fBNVML_ERROR_UNINITIALIZED\fP if the library has not been successfully initialized
.IP "\(bu" 2
\fBNVML_ERROR_INVALID_ARGUMENT\fP if \fIvgpuInstance\fP is 0, or \fIfbUsage\fP is NULL
.IP "\(bu" 2
\fBNVML_ERROR_NOT_FOUND\fP if \fIvgpuInstance\fP does not match a valid active vGPU instance on the system
.IP "\(bu" 2
\fBNVML_ERROR_UNKNOWN\fP on any unexpected error 
.PP
.RE
.PP

.SS "\fBnvmlReturn_t\fP DECLDIR nvmlVgpuInstanceGetFrameRateLimit (nvmlVgpuInstance_t vgpuInstance, unsigned int * frameRateLimit)"
.PP
Retrieve the frame rate limit set for the vGPU instance.
.PP
Returns the value of the frame rate limit set for the vGPU instance
.PP
For Kepler (TM) or newer fully supported devices.
.PP
\fBParameters:\fP
.RS 4
\fIvgpuInstance\fP Identifier of the target vGPU instance 
.br
\fIframeRateLimit\fP Reference to return the frame rate limit
.RE
.PP
\fBReturns:\fP
.RS 4
.IP "\(bu" 2
\fBNVML_SUCCESS\fP if \fIframeRateLimit\fP has been set
.IP "\(bu" 2
\fBNVML_ERROR_NOT_SUPPORTED\fP if frame rate limiter is turned off for the vGPU type
.IP "\(bu" 2
\fBNVML_ERROR_UNINITIALIZED\fP if the library has not been successfully initialized
.IP "\(bu" 2
\fBNVML_ERROR_INVALID_ARGUMENT\fP if \fIvgpuInstance\fP is 0, or \fIframeRateLimit\fP is NULL
.IP "\(bu" 2
\fBNVML_ERROR_NOT_FOUND\fP if \fIvgpuInstance\fP does not match a valid active vGPU instance on the system
.IP "\(bu" 2
\fBNVML_ERROR_UNKNOWN\fP on any unexpected error 
.PP
.RE
.PP

.SS "\fBnvmlReturn_t\fP DECLDIR nvmlVgpuInstanceGetLicenseStatus (nvmlVgpuInstance_t vgpuInstance, unsigned int * licensed)"
.PP
Retrieve the current licensing state of the vGPU instance.
.PP
If the vGPU is currently licensed, \fIlicensed\fP is set to 1, otherwise it is set to 0.
.PP
For Kepler (TM) or newer fully supported devices.
.PP
\fBParameters:\fP
.RS 4
\fIvgpuInstance\fP Identifier of the target vGPU instance 
.br
\fIlicensed\fP Reference to return the licensing status
.RE
.PP
\fBReturns:\fP
.RS 4
.IP "\(bu" 2
\fBNVML_SUCCESS\fP if \fIlicensed\fP has been set
.IP "\(bu" 2
\fBNVML_ERROR_UNINITIALIZED\fP if the library has not been successfully initialized
.IP "\(bu" 2
\fBNVML_ERROR_INVALID_ARGUMENT\fP if \fIvgpuInstance\fP is 0, or \fIlicensed\fP is NULL
.IP "\(bu" 2
\fBNVML_ERROR_NOT_FOUND\fP if \fIvgpuInstance\fP does not match a valid active vGPU instance on the system
.IP "\(bu" 2
\fBNVML_ERROR_UNKNOWN\fP on any unexpected error 
.PP
.RE
.PP

.SS "\fBnvmlReturn_t\fP DECLDIR nvmlVgpuInstanceGetType (nvmlVgpuInstance_t vgpuInstance, nvmlVgpuTypeId_t * vgpuTypeId)"
.PP
Retrieve the vGPU type of a vGPU instance.
.PP
Returns the vGPU type ID of vgpu assigned to the vGPU instance.
.PP
For Kepler (TM) or newer fully supported devices.
.PP
\fBParameters:\fP
.RS 4
\fIvgpuInstance\fP Identifier of the target vGPU instance 
.br
\fIvgpuTypeId\fP Reference to return the vgpuTypeId
.RE
.PP
\fBReturns:\fP
.RS 4
.IP "\(bu" 2
\fBNVML_SUCCESS\fP if \fIvgpuTypeId\fP has been set
.IP "\(bu" 2
\fBNVML_ERROR_UNINITIALIZED\fP if the library has not been successfully initialized
.IP "\(bu" 2
\fBNVML_ERROR_INVALID_ARGUMENT\fP if \fIvgpuInstance\fP is 0, or \fIvgpuTypeId\fP is NULL
.IP "\(bu" 2
\fBNVML_ERROR_NOT_FOUND\fP if \fIvgpuInstance\fP does not match a valid active vGPU instance on the system
.IP "\(bu" 2
\fBNVML_ERROR_UNKNOWN\fP on any unexpected error 
.PP
.RE
.PP

.SS "\fBnvmlReturn_t\fP DECLDIR nvmlVgpuInstanceGetUUID (nvmlVgpuInstance_t vgpuInstance, char * uuid, unsigned int size)"
.PP
Retrieve the UUID of a vGPU instance.
.PP
The UUID is a globally unique identifier associated with the vGPU, and is returned as a 5-part hexadecimal string, not exceeding 80 characters in length (including the NULL terminator). See \fBnvmlConstants::NVML_DEVICE_UUID_BUFFER_SIZE\fP.
.PP
For Kepler (TM) or newer fully supported devices.
.PP
\fBParameters:\fP
.RS 4
\fIvgpuInstance\fP Identifier of the target vGPU instance 
.br
\fIuuid\fP Pointer to caller-supplied buffer to hold vGPU UUID 
.br
\fIsize\fP Size of buffer in bytes
.RE
.PP
\fBReturns:\fP
.RS 4
.IP "\(bu" 2
\fBNVML_SUCCESS\fP successful completion
.IP "\(bu" 2
\fBNVML_ERROR_UNINITIALIZED\fP if the library has not been successfully initialized
.IP "\(bu" 2
\fBNVML_ERROR_INVALID_ARGUMENT\fP if \fIvgpuInstance\fP is 0, or \fIuuid\fP is NULL
.IP "\(bu" 2
\fBNVML_ERROR_NOT_FOUND\fP if \fIvgpuInstance\fP does not match a valid active vGPU instance on the system
.IP "\(bu" 2
\fBNVML_ERROR_INSUFFICIENT_SIZE\fP if \fIsize\fP is too small
.IP "\(bu" 2
\fBNVML_ERROR_UNKNOWN\fP on any unexpected error 
.PP
.RE
.PP

.SS "\fBnvmlReturn_t\fP DECLDIR nvmlVgpuInstanceGetVmDriverVersion (nvmlVgpuInstance_t vgpuInstance, char * version, unsigned int length)"
.PP
Retrieve the NVIDIA driver version installed in the VM associated with a vGPU.
.PP
The version is returned as an alphanumeric string in the caller-supplied buffer \fIversion\fP. The length of the version string will not exceed 80 characters in length (including the NUL terminator). See \fBnvmlConstants::NVML_SYSTEM_DRIVER_VERSION_BUFFER_SIZE\fP.
.PP
\fBnvmlVgpuInstanceGetVmDriverVersion()\fP may be called at any time for a vGPU instance. The guest VM driver version is returned as 'Unknown' if no NVIDIA driver is installed in the VM, or the VM has not yet booted to the point where the NVIDIA driver is loaded and initialized.
.PP
For Kepler (TM) or newer fully supported devices.
.PP
\fBParameters:\fP
.RS 4
\fIvgpuInstance\fP Identifier of the target vGPU instance 
.br
\fIversion\fP Caller-supplied buffer to return driver version string 
.br
\fIlength\fP Size of \fIversion\fP buffer
.RE
.PP
\fBReturns:\fP
.RS 4
.IP "\(bu" 2
\fBNVML_SUCCESS\fP if \fIversion\fP has been set
.IP "\(bu" 2
\fBNVML_ERROR_UNINITIALIZED\fP if the library has not been successfully initialized
.IP "\(bu" 2
\fBNVML_ERROR_INVALID_ARGUMENT\fP if \fIvgpuInstance\fP is 0
.IP "\(bu" 2
\fBNVML_ERROR_NOT_FOUND\fP if \fIvgpuInstance\fP does not match a valid active vGPU instance on the system
.IP "\(bu" 2
\fBNVML_ERROR_INSUFFICIENT_SIZE\fP if \fIlength\fP is too small
.IP "\(bu" 2
\fBNVML_ERROR_UNKNOWN\fP on any unexpected error 
.PP
.RE
.PP

.SS "\fBnvmlReturn_t\fP DECLDIR nvmlVgpuInstanceGetVmID (nvmlVgpuInstance_t vgpuInstance, char * vmId, unsigned int size, \fBnvmlVgpuVmIdType_t\fP * vmIdType)"
.PP
Retrieve the VM ID associated with a vGPU instance.
.PP
The VM ID is returned as a string, not exceeding 80 characters in length (including the NUL terminator). See \fBnvmlConstants::NVML_DEVICE_UUID_BUFFER_SIZE\fP.
.PP
The format of the VM ID varies by platform, and is indicated by the type identifier returned in \fIvmIdType\fP.
.PP
For Kepler (TM) or newer fully supported devices.
.PP
\fBParameters:\fP
.RS 4
\fIvgpuInstance\fP Identifier of the target vGPU instance 
.br
\fIvmId\fP Pointer to caller-supplied buffer to hold VM ID 
.br
\fIsize\fP Size of buffer in bytes 
.br
\fIvmIdType\fP Pointer to hold VM ID type
.RE
.PP
\fBReturns:\fP
.RS 4
.IP "\(bu" 2
\fBNVML_SUCCESS\fP successful completion
.IP "\(bu" 2
\fBNVML_ERROR_UNINITIALIZED\fP if the library has not been successfully initialized
.IP "\(bu" 2
\fBNVML_ERROR_INVALID_ARGUMENT\fP if \fIvmId\fP or \fIvmIdType\fP is NULL, or \fIvgpuInstance\fP is 0
.IP "\(bu" 2
\fBNVML_ERROR_NOT_FOUND\fP if \fIvgpuInstance\fP does not match a valid active vGPU instance on the system
.IP "\(bu" 2
\fBNVML_ERROR_INSUFFICIENT_SIZE\fP if \fIsize\fP is too small
.IP "\(bu" 2
\fBNVML_ERROR_UNKNOWN\fP on any unexpected error 
.PP
.RE
.PP

.SS "\fBnvmlReturn_t\fP DECLDIR nvmlVgpuInstanceSetEncoderCapacity (nvmlVgpuInstance_t vgpuInstance, unsigned int encoderCapacity)"
.PP
Set the encoder capacity of a vGPU instance, as a percentage of maximum encoder capacity with valid values in the range 0-100.
.PP
For Maxwell (TM) or newer fully supported devices.
.PP
\fBParameters:\fP
.RS 4
\fIvgpuInstance\fP Identifier of the target vGPU instance 
.br
\fIencoderCapacity\fP Unsigned int for the encoder capacity value
.RE
.PP
\fBReturns:\fP
.RS 4
.IP "\(bu" 2
\fBNVML_SUCCESS\fP if \fIencoderCapacity\fP has been set
.IP "\(bu" 2
\fBNVML_ERROR_UNINITIALIZED\fP if the library has not been successfully initialized
.IP "\(bu" 2
\fBNVML_ERROR_INVALID_ARGUMENT\fP if \fIvgpuInstance\fP is 0, or \fIencoderCapacity\fP is out of range of 0-100.
.IP "\(bu" 2
\fBNVML_ERROR_NOT_FOUND\fP if \fIvgpuInstance\fP does not match a valid active vGPU instance on the system
.IP "\(bu" 2
\fBNVML_ERROR_UNKNOWN\fP on any unexpected error 
.PP
.RE
.PP

.SS "\fBnvmlReturn_t\fP DECLDIR nvmlVgpuTypeGetClass (nvmlVgpuTypeId_t vgpuTypeId, char * vgpuTypeClass, unsigned int * size)"
.PP
Retrieve the class of a vGPU type. It will not exceed 64 characters in length (including the NUL terminator). See \fBnvmlConstants::NVML_DEVICE_NAME_BUFFER_SIZE\fP.
.PP
For Kepler (TM) or newer fully supported devices.
.PP
\fBParameters:\fP
.RS 4
\fIvgpuTypeId\fP Handle to vGPU type 
.br
\fIvgpuTypeClass\fP Pointer to string array to return class in 
.br
\fIsize\fP Size of string
.RE
.PP
\fBReturns:\fP
.RS 4
.IP "\(bu" 2
\fBNVML_SUCCESS\fP successful completion
.IP "\(bu" 2
\fBNVML_ERROR_INVALID_ARGUMENT\fP if \fIvgpuTypeId\fP is invalid, or \fIvgpuTypeClass\fP is NULL
.IP "\(bu" 2
\fBNVML_ERROR_INSUFFICIENT_SIZE\fP if \fIsize\fP is too small
.IP "\(bu" 2
\fBNVML_ERROR_UNKNOWN\fP on any unexpected error 
.PP
.RE
.PP

.SS "\fBnvmlReturn_t\fP DECLDIR nvmlVgpuTypeGetDeviceID (nvmlVgpuTypeId_t vgpuTypeId, unsigned long long * deviceID, unsigned long long * subsystemID)"
.PP
Retrieve the device ID of a vGPU type.
.PP
For Kepler (TM) or newer fully supported devices.
.PP
\fBParameters:\fP
.RS 4
\fIvgpuTypeId\fP Handle to vGPU type 
.br
\fIdeviceID\fP Device ID and vendor ID of the device contained in single 32 bit value 
.br
\fIsubsystemID\fP Subsytem ID and subsytem vendor ID of the device contained in single 32 bit value
.RE
.PP
\fBReturns:\fP
.RS 4
.IP "\(bu" 2
\fBNVML_SUCCESS\fP successful completion
.IP "\(bu" 2
\fBNVML_ERROR_UNINITIALIZED\fP if the library has not been successfully initialized
.IP "\(bu" 2
\fBNVML_ERROR_INVALID_ARGUMENT\fP if \fIvgpuTypeId\fP is invalid, or \fIdeviceId\fP or \fIsubsystemID\fP are NULL
.IP "\(bu" 2
\fBNVML_ERROR_UNKNOWN\fP on any unexpected error 
.PP
.RE
.PP

.SS "\fBnvmlReturn_t\fP DECLDIR nvmlVgpuTypeGetFramebufferSize (nvmlVgpuTypeId_t vgpuTypeId, unsigned long long * fbSize)"
.PP
Retrieve the vGPU framebuffer size in bytes.
.PP
For Kepler (TM) or newer fully supported devices.
.PP
\fBParameters:\fP
.RS 4
\fIvgpuTypeId\fP Handle to vGPU type 
.br
\fIfbSize\fP Pointer to framebuffer size in bytes
.RE
.PP
\fBReturns:\fP
.RS 4
.IP "\(bu" 2
\fBNVML_SUCCESS\fP successful completion
.IP "\(bu" 2
\fBNVML_ERROR_UNINITIALIZED\fP if the library has not been successfully initialized
.IP "\(bu" 2
\fBNVML_ERROR_INVALID_ARGUMENT\fP if \fIvgpuTypeId\fP is invalid, or \fIfbSize\fP is NULL
.IP "\(bu" 2
\fBNVML_ERROR_UNKNOWN\fP on any unexpected error 
.PP
.RE
.PP

.SS "\fBnvmlReturn_t\fP DECLDIR nvmlVgpuTypeGetFrameRateLimit (nvmlVgpuTypeId_t vgpuTypeId, unsigned int * frameRateLimit)"
.PP
Retrieve the static frame rate limit value of the vGPU type
.PP
For Kepler (TM) or newer fully supported devices.
.PP
\fBParameters:\fP
.RS 4
\fIvgpuTypeId\fP Handle to vGPU type 
.br
\fIframeRateLimit\fP Reference to return the frame rate limit value 
.RE
.PP
\fBReturns:\fP
.RS 4
.IP "\(bu" 2
\fBNVML_SUCCESS\fP successful completion
.IP "\(bu" 2
\fBNVML_ERROR_NOT_SUPPORTED\fP if frame rate limiter is turned off for the vGPU type
.IP "\(bu" 2
\fBNVML_ERROR_UNINITIALIZED\fP if the library has not been successfully initialized
.IP "\(bu" 2
\fBNVML_ERROR_INVALID_ARGUMENT\fP if \fIvgpuTypeId\fP is invalid, or \fIframeRateLimit\fP is NULL
.IP "\(bu" 2
\fBNVML_ERROR_UNKNOWN\fP on any unexpected error 
.PP
.RE
.PP

.SS "\fBnvmlReturn_t\fP DECLDIR nvmlVgpuTypeGetLicense (nvmlVgpuTypeId_t vgpuTypeId, char * vgpuTypeLicenseString, unsigned int size)"
.PP
Retrieve license requirements for a vGPU type
.PP
The license type and version required to run the specified vGPU type is returned as an alphanumeric string, in the form '<license name>,<version>', for example 'GRID-Virtual-PC,2.0'. If a vGPU is runnable with* more than one type of license, the licenses are delimited by a semicolon, for example 'GRID-Virtual-PC,2.0;GRID-Virtual-WS,2.0;GRID-Virtual-WS-Ext,2.0'.
.PP
The total length of the returned string will not exceed 128 characters, including the NUL terminator. See \fBnvmlVgpuConstants::NVML_GRID_LICENSE_BUFFER_SIZE\fP.
.PP
For Kepler (TM) or newer fully supported devices.
.PP
\fBParameters:\fP
.RS 4
\fIvgpuTypeId\fP Handle to vGPU type 
.br
\fIvgpuTypeLicenseString\fP Pointer to buffer to return license info 
.br
\fIsize\fP Size of \fIvgpuTypeLicenseString\fP buffer
.RE
.PP
\fBReturns:\fP
.RS 4
.IP "\(bu" 2
\fBNVML_SUCCESS\fP successful completion
.IP "\(bu" 2
\fBNVML_ERROR_UNINITIALIZED\fP if the library has not been successfully initialized
.IP "\(bu" 2
\fBNVML_ERROR_INVALID_ARGUMENT\fP if \fIvgpuTypeId\fP is invalid, or \fIvgpuTypeLicenseString\fP is NULL
.IP "\(bu" 2
\fBNVML_ERROR_INSUFFICIENT_SIZE\fP if \fIsize\fP is too small
.IP "\(bu" 2
\fBNVML_ERROR_UNKNOWN\fP on any unexpected error 
.PP
.RE
.PP

.SS "\fBnvmlReturn_t\fP DECLDIR nvmlVgpuTypeGetMaxInstances (nvmlDevice_t device, nvmlVgpuTypeId_t vgpuTypeId, unsigned int * vgpuInstanceCount)"
.PP
Retrieve the maximum number of vGPU instances creatable on a device for given vGPU type
.PP
For Kepler (TM) or newer fully supported devices.
.PP
\fBParameters:\fP
.RS 4
\fIdevice\fP The identifier of the target device 
.br
\fIvgpuTypeId\fP Handle to vGPU type 
.br
\fIvgpuInstanceCount\fP Pointer to get the max number of vGPU instances that can be created on a deicve for given vgpuTypeId 
.RE
.PP
\fBReturns:\fP
.RS 4
.IP "\(bu" 2
\fBNVML_SUCCESS\fP successful completion
.IP "\(bu" 2
\fBNVML_ERROR_UNINITIALIZED\fP if the library has not been successfully initialized
.IP "\(bu" 2
\fBNVML_ERROR_INVALID_ARGUMENT\fP if \fIvgpuTypeId\fP is invalid or is not supported on target device, or \fIvgpuInstanceCount\fP is NULL
.IP "\(bu" 2
\fBNVML_ERROR_UNKNOWN\fP on any unexpected error 
.PP
.RE
.PP

.SS "\fBnvmlReturn_t\fP DECLDIR nvmlVgpuTypeGetMaxInstancesPerVm (nvmlVgpuTypeId_t vgpuTypeId, unsigned int * vgpuInstanceCountPerVm)"
.PP
Retrieve the maximum number of vGPU instances supported per VM for given vGPU type
.PP
For Kepler (TM) or newer fully supported devices.
.PP
\fBParameters:\fP
.RS 4
\fIvgpuTypeId\fP Handle to vGPU type 
.br
\fIvgpuInstanceCountPerVm\fP Pointer to get the max number of vGPU instances supported per VM for given \fIvgpuTypeId\fP 
.RE
.PP
\fBReturns:\fP
.RS 4
.IP "\(bu" 2
\fBNVML_SUCCESS\fP successful completion
.IP "\(bu" 2
\fBNVML_ERROR_UNINITIALIZED\fP if the library has not been successfully initialized
.IP "\(bu" 2
\fBNVML_ERROR_INVALID_ARGUMENT\fP if \fIvgpuTypeId\fP is invalid, or \fIvgpuInstanceCountPerVm\fP is NULL
.IP "\(bu" 2
\fBNVML_ERROR_UNKNOWN\fP on any unexpected error 
.PP
.RE
.PP

.SS "\fBnvmlReturn_t\fP DECLDIR nvmlVgpuTypeGetName (nvmlVgpuTypeId_t vgpuTypeId, char * vgpuTypeName, unsigned int * size)"
.PP
Retrieve the vGPU type name.
.PP
The name is an alphanumeric string that denotes a particular vGPU, e.g. GRID M60-2Q. It will not exceed 64 characters in length (including the NUL terminator). See \fBnvmlConstants::NVML_DEVICE_NAME_BUFFER_SIZE\fP.
.PP
For Kepler (TM) or newer fully supported devices.
.PP
\fBParameters:\fP
.RS 4
\fIvgpuTypeId\fP Handle to vGPU type 
.br
\fIvgpuTypeName\fP Pointer to buffer to return name 
.br
\fIsize\fP Size of buffer
.RE
.PP
\fBReturns:\fP
.RS 4
.IP "\(bu" 2
\fBNVML_SUCCESS\fP successful completion
.IP "\(bu" 2
\fBNVML_ERROR_INVALID_ARGUMENT\fP if \fIvgpuTypeId\fP is invalid, or \fIname\fP is NULL
.IP "\(bu" 2
\fBNVML_ERROR_INSUFFICIENT_SIZE\fP if \fIsize\fP is too small
.IP "\(bu" 2
\fBNVML_ERROR_UNKNOWN\fP on any unexpected error 
.PP
.RE
.PP

.SS "\fBnvmlReturn_t\fP DECLDIR nvmlVgpuTypeGetNumDisplayHeads (nvmlVgpuTypeId_t vgpuTypeId, unsigned int * numDisplayHeads)"
.PP
Retrieve count of vGPU's supported display heads.
.PP
For Kepler (TM) or newer fully supported devices.
.PP
\fBParameters:\fP
.RS 4
\fIvgpuTypeId\fP Handle to vGPU type 
.br
\fInumDisplayHeads\fP Pointer to number of display heads
.RE
.PP
\fBReturns:\fP
.RS 4
.IP "\(bu" 2
\fBNVML_SUCCESS\fP successful completion
.IP "\(bu" 2
\fBNVML_ERROR_UNINITIALIZED\fP if the library has not been successfully initialized
.IP "\(bu" 2
\fBNVML_ERROR_INVALID_ARGUMENT\fP if \fIvgpuTypeId\fP is invalid, or \fInumDisplayHeads\fP is NULL
.IP "\(bu" 2
\fBNVML_ERROR_UNKNOWN\fP on any unexpected error 
.PP
.RE
.PP

.SS "\fBnvmlReturn_t\fP DECLDIR nvmlVgpuTypeGetResolution (nvmlVgpuTypeId_t vgpuTypeId, unsigned int displayIndex, unsigned int * xdim, unsigned int * ydim)"
.PP
Retrieve vGPU display head's maximum supported resolution.
.PP
For Kepler (TM) or newer fully supported devices.
.PP
\fBParameters:\fP
.RS 4
\fIvgpuTypeId\fP Handle to vGPU type 
.br
\fIdisplayIndex\fP Zero-based index of display head 
.br
\fIxdim\fP Pointer to maximum number of pixels in X dimension 
.br
\fIydim\fP Pointer to maximum number of pixels in Y dimension
.RE
.PP
\fBReturns:\fP
.RS 4
.IP "\(bu" 2
\fBNVML_SUCCESS\fP successful completion
.IP "\(bu" 2
\fBNVML_ERROR_UNINITIALIZED\fP if the library has not been successfully initialized
.IP "\(bu" 2
\fBNVML_ERROR_INVALID_ARGUMENT\fP if \fIvgpuTypeId\fP is invalid, or \fIxdim\fP or \fIydim\fP are NULL, or \fIdisplayIndex\fP is out of range.
.IP "\(bu" 2
\fBNVML_ERROR_UNKNOWN\fP on any unexpected error 
.PP
.RE
.PP

.SH "Author"
.PP 
Generated automatically by Doxygen for NVML from the source code.