benchSANVML.c File Reference

Include dependency graph for benchSANVML.c:

Go to the source code of this file.

Data Structures
union	uPointer_t
union	convert_64_t

Macros
#define	CUDAAPI   __attribute__((weak))
#define	CUDARTAPI   __attribute__((weak))
#define	DECLDIR   __attribute__((weak))
#define	_prog_fprintf   if (1) fprintf /* change to 1 to enable printing of progress debug messages. TURN OFF if benchmark timing. */
#define	_time_fprintf   if (1) fprintf /* change to 1 to enable printing of performance timings. TURN OFF if benchmark timing. */
#define	mCheck_DL_Status(err, str)
#define	STRINGIFY(x)   #x
#define	TOSTRING(x)   STRINGIFY(x)
#define	mGet_DL_FPtr(libPtr, Name)
#define	hostnameLen   512 /* constant used multiple times. */

Functions
CUresult CUDAAPI	cuInit (unsigned int myInt)
cudaError_t CUDARTAPI	cudaGetDevice (int *dest)
cudaError_t CUDARTAPI	cudaGetDeviceCount (int *dest)
cudaError_t CUDARTAPI	cudaDeviceGetPCIBusId (char *, int, int)
const char *DECLDIR	nvmlErrorString (nvmlReturn_t)
nvmlReturn_t DECLDIR	nvmlDeviceGetClockInfo (nvmlDevice_t, nvmlClockType_t, unsigned int *)
nvmlReturn_t DECLDIR	nvmlDeviceGetCount (unsigned int *dest)
nvmlReturn_t DECLDIR	nvmlDeviceGetDetailedEccErrors (nvmlDevice_t, nvmlEccBitType_t, nvmlEccCounterType_t, nvmlEccErrorCounts_t *)
nvmlReturn_t DECLDIR	nvmlDeviceGetEccMode (nvmlDevice_t, nvmlEnableState_t *, nvmlEnableState_t *)
nvmlReturn_t DECLDIR	nvmlDeviceGetFanSpeed (nvmlDevice_t, unsigned int *)
nvmlReturn_t DECLDIR	nvmlDeviceGetHandleByIndex (unsigned int idx, nvmlDevice_t *dest)
nvmlReturn_t DECLDIR	nvmlDeviceGetInforomVersion (nvmlDevice_t, nvmlInforomObject_t, char *, unsigned int)
nvmlReturn_t DECLDIR	nvmlDeviceGetMemoryInfo (nvmlDevice_t, nvmlMemory_t *)
nvmlReturn_t DECLDIR	nvmlDeviceGetName (nvmlDevice_t device, char *name, unsigned int len)
nvmlReturn_t DECLDIR	nvmlDeviceGetPciInfo (nvmlDevice_t, nvmlPciInfo_t *)
nvmlReturn_t DECLDIR	nvmlDeviceGetPerformanceState (nvmlDevice_t, nvmlPstates_t *)
nvmlReturn_t DECLDIR	nvmlDeviceGetPowerManagementLimit (nvmlDevice_t device, unsigned int *limit)
nvmlReturn_t DECLDIR	nvmlDeviceGetPowerManagementLimitConstraints (nvmlDevice_t device, unsigned int *minLimit, unsigned int *maxLimit)
nvmlReturn_t DECLDIR	nvmlDeviceGetPowerUsage (nvmlDevice_t device, unsigned int *dest)
nvmlReturn_t DECLDIR	nvmlDeviceGetTemperature (nvmlDevice_t, nvmlTemperatureSensors_t, unsigned int *)
nvmlReturn_t DECLDIR	nvmlDeviceGetTotalEccErrors (nvmlDevice_t, nvmlEccBitType_t, nvmlEccCounterType_t, unsigned long long *)
nvmlReturn_t DECLDIR	nvmlDeviceGetUtilizationRates (nvmlDevice_t, nvmlUtilization_t *)
nvmlReturn_t DECLDIR	nvmlDeviceSetPowerManagementLimit (nvmlDevice_t device, unsigned int limit)
nvmlReturn_t DECLDIR	nvmlInit (void)
nvmlReturn_t DECLDIR	nvmlShutdown (void)
int	main (int argc, char **argv)

Variables
CUresult CUDAAPI(*	cuInitPtr )(unsigned int)
cudaError_t(*	cudaGetDevicePtr )(int *)
cudaError_t(*	cudaGetDeviceCountPtr )(int *)
cudaError_t(*	cudaDeviceGetPCIBusIdPtr )(char *, int, int)
char *(*	nvmlErrorStringPtr )(nvmlReturn_t)
nvmlReturn_t(*	nvmlDeviceGetClockInfoPtr )(nvmlDevice_t, nvmlClockType_t, unsigned int *)
nvmlReturn_t(*	nvmlDeviceGetCountPtr )(unsigned int *dest)
nvmlReturn_t(*	nvmlDeviceGetDetailedEccErrorsPtr )(nvmlDevice_t, nvmlEccBitType_t, nvmlEccCounterType_t, nvmlEccErrorCounts_t *)
nvmlReturn_t(*	nvmlDeviceGetEccModePtr )(nvmlDevice_t, nvmlEnableState_t *, nvmlEnableState_t *)
nvmlReturn_t(*	nvmlDeviceGetFanSpeedPtr )(nvmlDevice_t, unsigned int *)
nvmlReturn_t(*	nvmlDeviceGetHandleByIndexPtr )(unsigned int, nvmlDevice_t *)
nvmlReturn_t(*	nvmlDeviceGetInforomVersionPtr )(nvmlDevice_t, nvmlInforomObject_t, char *, unsigned int)
nvmlReturn_t(*	nvmlDeviceGetMemoryInfoPtr )(nvmlDevice_t, nvmlMemory_t *)
nvmlReturn_t(*	nvmlDeviceGetNamePtr )(nvmlDevice_t, char *, unsigned int)
nvmlReturn_t(*	nvmlDeviceGetPciInfoPtr )(nvmlDevice_t, nvmlPciInfo_t *)
nvmlReturn_t(*	nvmlDeviceGetPerformanceStatePtr )(nvmlDevice_t, nvmlPstates_t *)
nvmlReturn_t(*	nvmlDeviceGetPowerManagementLimitConstraintsPtr )(nvmlDevice_t device, unsigned int *minLimit, unsigned int *maxLimit)
nvmlReturn_t(*	nvmlDeviceGetPowerManagementLimitPtr )(nvmlDevice_t device, unsigned int *limit)
nvmlReturn_t(*	nvmlDeviceGetPowerUsagePtr )(nvmlDevice_t, unsigned int *)
nvmlReturn_t(*	nvmlDeviceGetTemperaturePtr )(nvmlDevice_t, nvmlTemperatureSensors_t, unsigned int *)
nvmlReturn_t(*	nvmlDeviceGetTotalEccErrorsPtr )(nvmlDevice_t, nvmlEccBitType_t, nvmlEccCounterType_t, unsigned long long *)
nvmlReturn_t(*	nvmlDeviceGetUtilizationRatesPtr )(nvmlDevice_t, nvmlUtilization_t *)
nvmlReturn_t(*	nvmlDeviceSetPowerManagementLimitPtr )(nvmlDevice_t device, unsigned int limit)
nvmlReturn_t(*	nvmlInitPtr )(void)
nvmlReturn_t(*	nvmlShutdownPtr )(void)
static void *	dl1 = NULL
static void *	dl2 = NULL
static void *	dl3 = NULL
static struct timeval t1	t2
void(*	_dl_non_dynamic_init )(void)

Macro Definition Documentation

_prog_fprintf

#define _prog_fprintf   if (1) fprintf /* change to 1 to enable printing of progress debug messages. TURN OFF if benchmark timing. */

Definition at line 154 of file benchSANVML.c.

_time_fprintf

#define _time_fprintf   if (1) fprintf /* change to 1 to enable printing of performance timings. TURN OFF if benchmark timing. */

Definition at line 155 of file benchSANVML.c.

CUDAAPI

#define CUDAAPI   __attribute__((weak))

Definition at line 46 of file benchSANVML.c.

CUDARTAPI

#define CUDARTAPI   __attribute__((weak))

Definition at line 51 of file benchSANVML.c.

DECLDIR

#define DECLDIR   __attribute__((weak))

Definition at line 62 of file benchSANVML.c.

hostnameLen

#define hostnameLen   512 /* constant used multiple times. */

mCheck_DL_Status

#define mCheck_DL_Status	(		err,
			str
	)

Value:

if( err )                                                                  \
   {                                                                          \
      fprintf(stderr, str);                                                   \
      return(-1);                                                             \
   }

mGet_DL_FPtr

#define mGet_DL_FPtr	(		libPtr,
			Name
	)

Value:

Name##Ptr = dlsym(libPtr, TOSTRING(Name));                              \
   mCheck_DL_Status(dlerror()!=NULL, TOSTRING(libPtr) " Library function " \
                  TOSTRING(Name) " not found.");

STRINGIFY

#define STRINGIFY

(

x

)

#x

TOSTRING

#define TOSTRING

(

x

)

STRINGIFY(x)

Function Documentation

cudaDeviceGetPCIBusId()

cudaError_t CUDARTAPI cudaDeviceGetPCIBusId	(	char *	,
		int	,
		int
	)

cudaGetDevice()

cudaError_t CUDARTAPI cudaGetDevice

(

int *

dest

)

Definition at line 57 of file benchSANVML.c.

{return (*cudaGetDevicePtr)(dest); };

cudaGetDeviceCount()

cudaError_t CUDARTAPI cudaGetDeviceCount

(

int *

dest

)

Definition at line 58 of file benchSANVML.c.

{return (*cudaGetDeviceCountPtr)(dest);}

Here is the caller graph for this function:

cuInit()

CUresult CUDAAPI cuInit

(

unsigned int

myInt

)

Definition at line 48 of file benchSANVML.c.

{return (*cuInitPtr)(myInt);}

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 269 of file benchSANVML.c.

{
   (void) argc; (void) argv;                                            // Prevent not used warning.
   #define hostnameLen 512 /* constant used multiple times. */
   char hostname[hostnameLen];                                          // host name.
   int  i, j, ret;
   int cuda_count, nvml_count;
    nvmlReturn_t nvret;
    cudaError_t cuerr;

   //-------------------------------------------------------------------
   // Begin initialization timing.
   //-------------------------------------------------------------------

   gettimeofday(&t1, NULL);
   ret = _local_linkDynamicLibraries();
   if ( ret != 0) {                                                     // Failure to get lib.
      fprintf(stderr, "Failed attempt to link to CUDA and NVML libraries.");
      exit(-1); 
   }

   _prog_fprintf(stderr, "Linked to CUDA and NVML libraries\n");        // debug only; turn off if timing.
   
   nvret = nvmlInit();                                                  // Initialize the library.
   if (nvret != NVML_SUCCESS) {
      fprintf(stderr, "Failed nvmlInit(), ret=%i [%s].\n", nvret, nvmlErrorString(nvret));
      exit(-1);
   }

   nvret = cuInit(0);                                                   // Initialize the CUDA library.
   if (nvret != cudaSuccess) {
      fprintf(stderr, "Failed cuInit(0).\n");
      exit(-1);
   }

   nvret = nvmlDeviceGetCount(&nvml_count);                             // Get the device count.
   if (nvret != NVML_SUCCESS) {
      fprintf(stderr, "nvmlDeviceGetCount failed; ret=%i.\n", nvret);   // Report an error.
      exit(-1);
   }

   nvret = cudaGetDeviceCount(&cuda_count);                             // Get the device count.
   if (nvret != cudaSuccess) {
      fprintf(stderr, "cudaGetDeviceCount failed; ret=%i.\n", nvret);   // Report an error.
      exit(-1);
   }


   ret = gethostname(hostname, hostnameLen);                            // Try to get the host hame.
   if( gethostname(hostname, hostnameLen) != 0) {                       // If we can't get the hostname, 
      fprintf(stderr, "Failed system call, gethostname() "
            "returned %i.", ret);
   exit(-1);
   }
   #undef hostnameLen /* done with it. */

   fprintf(stderr, "hostname: %s\n"
                   "nvml_count=%i\n"
                   "cuda_count=%i\n", hostname, nvml_count, cuda_count);

   nvmlDevice_t *handle = malloc(nvml_count * sizeof(nvmlDevice_t));    // for all device handles.
   char name[128];                                                      // space for device name.
   unsigned int powerUsage, powerLimit, powerLimit2;                    // for the power usage and limit.
   unsigned int minPower, maxPower;                                     // Minimum and Maximum power.

   // scan all the devices.
   for (i=0; i<nvml_count; i++) {                                       // Get all the handles; print as we go.
      nvret = nvmlDeviceGetHandleByIndex(i, &handle[i]);                // Read the handle.
      if (nvret != NVML_SUCCESS) {
         fprintf(stderr, "nvmlDeviceGetHandleByIndex %i failed; nvret=%i [%s].\n", i, nvret, nvmlErrorString(nvret));
         handle[i]=NULL;                                                // Set to bad value. 
         continue;                                                      // skip trying this one.
      }
 
      fprintf(stderr, "Handle %i: %016lX\n", i, handle[i]);             // Show the handles.

      nvret = nvmlDeviceGetName(handle[i], name, sizeof(name)-1);       // Get the name.
      name[sizeof(name)-1]='\0';                                        // Ensure z-termination.
      fprintf(stderr, "Name='%s'.\n", name);                            // Show the name.

      nvret = nvmlDeviceGetPowerUsage(handle[i], &powerUsage);          // Attempt to get power usage.
      if (nvret != NVML_SUCCESS) {                                      // If it failed,
         fprintf(stderr, "nvmlDeviceGetPowerUsage failed; nvret=%i [%s]\n", nvret, nvmlErrorString(nvret));
      } else {
         fprintf(stderr, "nvmlDeviceGetPowerUsage succeeded, value returned=%u mw.\n", powerUsage);
      }

      nvret = nvmlDeviceGetPowerManagementLimit(handle[i], &powerLimit);// Attempt to get power limit.
      if (nvret != NVML_SUCCESS) {                                      // If it failed,
         fprintf(stderr, "nvmlDeviceGetPowerManagementLimit failed; nvret=%i [%s]\n", nvret, nvmlErrorString(nvret));
      } else {
         fprintf(stderr, "nvmlDeviceGetPowerManagementLimit succeeded, value returned=%u mw.\n", powerLimit);
      }

      nvret = nvmlDeviceGetPowerManagementLimitConstraints(handle[i], &minPower, &maxPower);// Attempt to get min and max of power limit.
      if (nvret != NVML_SUCCESS) {                                      // If it failed,
         fprintf(stderr, "nvmlDeviceGetPowerManagementLimitConstraints failed; nvret=%i [%s]\n", nvret, nvmlErrorString(nvret));
      } else {
         fprintf(stderr, "nvmlDeviceGetPowerManagementLimitConstraints succeeded, values min=%u mw, max=%u mw.\n", minPower, maxPower);
      }

      // Test setting the power, to top-100.
      unsigned int newPower=maxPower-100;                                     // compute a new power setting.
      nvret = nvmlDeviceSetPowerManagementLimit(handle[i], newPower);         // Attempt to set it.
      if (nvret != NVML_SUCCESS) {                                            // If it failed,
         fprintf(stderr, "nvmlDeviceSetPowerManagementLimit to %i failed; nvret=%i [%s]\n", newPower, nvret, nvmlErrorString(nvret));
      } else {
         fprintf(stderr, "nvmlDeviceSetPowerManagementLimit to %i succeeded. (Routine call did not return error).\n", newPower);
      }

      nvret = nvmlDeviceGetPowerManagementLimit(handle[i], &powerLimit2);     // Attempt to get new power limit.
      if (nvret != NVML_SUCCESS) {                                            // If it failed,
         fprintf(stderr, "nvmlDeviceGetPowerManagementLimit failed; nvret=%i [%s]\n", nvret, nvmlErrorString(nvret));
      } else {
         fprintf(stderr, "nvmlDeviceGetPowerManagementLimit call to check setting succeeded, value returned=%u mw.\n", powerLimit2);
         if (powerLimit2 != newPower) {
            fprintf(stderr, "Note the check failed, the limit read is not the limit we tried to set.\n");
         } else {
            fprintf(stderr, "Note the check is a success, the power limit was changed.\n");
         }
      }

      nvret = nvmlDeviceSetPowerManagementLimit(handle[i], powerLimit);       // In case it works, set it back to where we found it.
      if (nvret != NVML_SUCCESS) {                                            // If it failed,
         fprintf(stderr, "nvmlDeviceSetPowerManagementLimit to restore %i failed; nvret=%i [%s]\n", powerLimit, nvret, nvmlErrorString(nvret));
      } else {
         fprintf(stderr, "nvmlDeviceSetPowerManagementLimit to restore %i succeeded.\n", powerLimit);
      }






   } // end of loop through devices.
 
   
   
   
   //-------------------------------------------------------------------
   // Cleanup, and shutdown.
   //-------------------------------------------------------------------

   return 0;
} // end MAIN routine.

Here is the call graph for this function:

nvmlDeviceGetClockInfo()

nvmlReturn_t DECLDIR nvmlDeviceGetClockInfo	(	nvmlDevice_t	,
		nvmlClockType_t	,
		unsigned int *
	)

nvmlDeviceGetCount()

nvmlReturn_t DECLDIR nvmlDeviceGetCount

(

unsigned int *

dest

)

Definition at line 88 of file benchSANVML.c.

{return (*nvmlDeviceGetCountPtr)(dest);}

Here is the caller graph for this function:

nvmlDeviceGetDetailedEccErrors()

nvmlReturn_t DECLDIR nvmlDeviceGetDetailedEccErrors	(	nvmlDevice_t	,
		nvmlEccBitType_t	,
		nvmlEccCounterType_t	,
		nvmlEccErrorCounts_t *
	)

nvmlDeviceGetEccMode()

nvmlReturn_t DECLDIR nvmlDeviceGetEccMode	(	nvmlDevice_t	,
		nvmlEnableState_t *	,
		nvmlEnableState_t *
	)

nvmlDeviceGetFanSpeed()

nvmlReturn_t DECLDIR nvmlDeviceGetFanSpeed	(	nvmlDevice_t	,
		unsigned int *
	)

nvmlDeviceGetHandleByIndex()

nvmlReturn_t DECLDIR nvmlDeviceGetHandleByIndex	(	unsigned int	idx,
		nvmlDevice_t *	dest
	)

Definition at line 92 of file benchSANVML.c.

{return (*nvmlDeviceGetHandleByIndexPtr)(idx, dest); }

Here is the caller graph for this function:

nvmlDeviceGetInforomVersion()

nvmlReturn_t DECLDIR nvmlDeviceGetInforomVersion	(	nvmlDevice_t	,
		nvmlInforomObject_t	,
		char *	,
		unsigned int
	)

nvmlDeviceGetMemoryInfo()

nvmlReturn_t DECLDIR nvmlDeviceGetMemoryInfo	(	nvmlDevice_t	,
		nvmlMemory_t *
	)

nvmlDeviceGetName()

nvmlReturn_t DECLDIR nvmlDeviceGetName	(	nvmlDevice_t	device,
		char *	name,
		unsigned int	len
	)

Definition at line 95 of file benchSANVML.c.

{(*nvmlDeviceGetNamePtr)(device, name, len); }

Here is the caller graph for this function:

nvmlDeviceGetPciInfo()

nvmlReturn_t DECLDIR nvmlDeviceGetPciInfo	(	nvmlDevice_t	,
		nvmlPciInfo_t *
	)

nvmlDeviceGetPerformanceState()

nvmlReturn_t DECLDIR nvmlDeviceGetPerformanceState	(	nvmlDevice_t	,
		nvmlPstates_t *
	)

nvmlDeviceGetPowerManagementLimit()

nvmlReturn_t DECLDIR nvmlDeviceGetPowerManagementLimit	(	nvmlDevice_t	device,
		unsigned int *	limit
	)

Definition at line 98 of file benchSANVML.c.

                                                                                                 {
                     (*nvmlDeviceGetPowerManagementLimitPtr)(device, limit); }

Here is the caller graph for this function:

nvmlDeviceGetPowerManagementLimitConstraints()

nvmlReturn_t DECLDIR nvmlDeviceGetPowerManagementLimitConstraints	(	nvmlDevice_t	device,
		unsigned int *	minLimit,
		unsigned int *	maxLimit
	)

Definition at line 100 of file benchSANVML.c.

                                                                                                                                       {
                     (*nvmlDeviceGetPowerManagementLimitConstraintsPtr)(device, minLimit, maxLimit); }

Here is the caller graph for this function:

nvmlDeviceGetPowerUsage()

nvmlReturn_t DECLDIR nvmlDeviceGetPowerUsage	(	nvmlDevice_t	device,
		unsigned int *	dest
	)

Definition at line 102 of file benchSANVML.c.

                                                                                      {
                     (*nvmlDeviceGetPowerUsagePtr)(device, dest); }

Here is the caller graph for this function:

nvmlDeviceGetTemperature()

nvmlReturn_t DECLDIR nvmlDeviceGetTemperature	(	nvmlDevice_t	,
		nvmlTemperatureSensors_t	,
		unsigned int *
	)

nvmlDeviceGetTotalEccErrors()

nvmlReturn_t DECLDIR nvmlDeviceGetTotalEccErrors	(	nvmlDevice_t	,
		nvmlEccBitType_t	,
		nvmlEccCounterType_t	,
		unsigned long long *
	)

nvmlDeviceGetUtilizationRates()

nvmlReturn_t DECLDIR nvmlDeviceGetUtilizationRates	(	nvmlDevice_t	,
		nvmlUtilization_t *
	)

nvmlDeviceSetPowerManagementLimit()

nvmlReturn_t DECLDIR nvmlDeviceSetPowerManagementLimit	(	nvmlDevice_t	device,
		unsigned int	limit
	)

Definition at line 107 of file benchSANVML.c.

                                                                                                 {
                     (*nvmlDeviceSetPowerManagementLimitPtr)(device, limit); }

Here is the caller graph for this function:

nvmlErrorString()

const char* DECLDIR nvmlErrorString

(

nvmlReturn_t

)

Here is the caller graph for this function:

nvmlInit()

nvmlReturn_t DECLDIR nvmlInit

(

void

)

Definition at line 109 of file benchSANVML.c.

{return (*nvmlInitPtr)();}

Here is the caller graph for this function:

nvmlShutdown()

nvmlReturn_t DECLDIR nvmlShutdown

(

void

)

Variable Documentation

_dl_non_dynamic_init

void(* _dl_non_dynamic_init) (void)

Definition at line 164 of file benchSANVML.c.

   {                                                                          \
      fprintf(stderr, str);                                                   \
      return(-1);                                                             \
   }

// keys for above: Init, InitThrd, InitCtlSt, Stop, ShutdownThrd, ShutdownCmp, Start,
// UpdateCtl, Read, Ctl, SetDom, Reset, Enum, EnumFirst, EnumNext, EnumUmasks, 
// NameToCode, CodeToName, CodeToDesc, CodeToInfo.

// Simplify routine below; relies on ptr names being same as func tags.
#define STRINGIFY(x) #x 
#define TOSTRING(x) STRINGIFY(x)
#define mGet_DL_FPtr(libPtr, Name)                                         \
   Name##Ptr = dlsym(libPtr, TOSTRING(Name));                              \
   mCheck_DL_Status(dlerror()!=NULL, TOSTRING(libPtr) " Library function " \
                  TOSTRING(Name) " not found.");

int _local_linkDynamicLibraries(void) 
{
   if (_dl_non_dynamic_init != NULL) {    // If weak var is present, we are statically linked instead of dynamically.
      fprintf(stderr, "NVML component does not support statically linked libc.");
      return (-1);
   }

   // Exit if we cannot link the cuda or NVML libs.
   dl1 = dlopen("libcuda.so", RTLD_NOW | RTLD_GLOBAL);
   if (!dl1) {
      fprintf(stderr, "CUDA library libcuda.so not found.");
      return (-1);
   }

   dl2 = dlopen("libcudart.so", RTLD_NOW | RTLD_GLOBAL | RTLD_NODELETE);
   if (!dl2) {
      fprintf(stderr, "CUDA runtime library libcudart.so not found.");
      return (-1);
   }

   dl3 = dlopen("libnvidia-ml.so", RTLD_NOW | RTLD_GLOBAL);
   if (!dl3) {
      fprintf(stderr, "NVML runtime library libnvidia-ml.so not found.");
       return (-1);
   }

//-----------------------------------------------------------------------------
// Collect pointers for routines in shared library.  All below will abort this
// routine with -1, the routine is not found in the dynamic library.
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// Collect pointers for routines in shared library.  All below will abort this
// routine with -1, the routine is not found in the dynamic library.
//-----------------------------------------------------------------------------

   mGet_DL_FPtr(dl1, cuInit);

   mGet_DL_FPtr(dl2, cudaGetDevice);
   mGet_DL_FPtr(dl2, cudaGetDeviceCount);
   mGet_DL_FPtr(dl2, cudaDeviceGetPCIBusId);

   mGet_DL_FPtr(dl3, nvmlDeviceGetClockInfo);
   mGet_DL_FPtr(dl3, nvmlErrorString);
   mGet_DL_FPtr(dl3, nvmlDeviceGetDetailedEccErrors);
   mGet_DL_FPtr(dl3, nvmlDeviceGetFanSpeed);
   mGet_DL_FPtr(dl3, nvmlDeviceGetMemoryInfo);
   mGet_DL_FPtr(dl3, nvmlDeviceGetPerformanceState);
   mGet_DL_FPtr(dl3, nvmlDeviceGetPowerUsage);
   mGet_DL_FPtr(dl3, nvmlDeviceGetTemperature);
   mGet_DL_FPtr(dl3, nvmlDeviceGetTotalEccErrors);
   mGet_DL_FPtr(dl3, nvmlDeviceGetUtilizationRates);
   mGet_DL_FPtr(dl3, nvmlDeviceGetHandleByIndex);
   mGet_DL_FPtr(dl3, nvmlDeviceGetPciInfo);
   mGet_DL_FPtr(dl3, nvmlDeviceGetName);
   mGet_DL_FPtr(dl3, nvmlDeviceGetInforomVersion);
   mGet_DL_FPtr(dl3, nvmlDeviceGetEccMode);
   mGet_DL_FPtr(dl3, nvmlInit);
   mGet_DL_FPtr(dl3, nvmlDeviceGetCount);
   mGet_DL_FPtr(dl3, nvmlShutdown);
   mGet_DL_FPtr(dl3, nvmlDeviceGetPowerManagementLimit);
   mGet_DL_FPtr(dl3, nvmlDeviceSetPowerManagementLimit);
   mGet_DL_FPtr(dl3, nvmlDeviceGetPowerManagementLimitConstraints);

   return 0;         // If we get here, all above succeeded. 
} // end routine.

cudaDeviceGetPCIBusIdPtr

cudaError_t(* cudaDeviceGetPCIBusIdPtr) (char *, int, int)

Definition at line 55 of file benchSANVML.c.

cudaGetDeviceCountPtr

cudaError_t(* cudaGetDeviceCountPtr) (int *)

Definition at line 54 of file benchSANVML.c.

cudaGetDevicePtr

cudaError_t(* cudaGetDevicePtr) (int *)

Definition at line 53 of file benchSANVML.c.

cuInitPtr

CUresult CUDAAPI(* cuInitPtr) (unsigned int)

Definition at line 47 of file benchSANVML.c.

dl1

void* dl1 = NULL

static

Definition at line 113 of file benchSANVML.c.

dl2

void* dl2 = NULL

static

Definition at line 114 of file benchSANVML.c.

dl3

void* dl3 = NULL

static

Definition at line 115 of file benchSANVML.c.

nvmlDeviceGetClockInfoPtr

nvmlReturn_t(* nvmlDeviceGetClockInfoPtr) (nvmlDevice_t, nvmlClockType_t, unsigned int *)

Definition at line 65 of file benchSANVML.c.

nvmlDeviceGetCountPtr

nvmlReturn_t(* nvmlDeviceGetCountPtr) (unsigned int *dest)

Definition at line 66 of file benchSANVML.c.

nvmlDeviceGetDetailedEccErrorsPtr

nvmlReturn_t(* nvmlDeviceGetDetailedEccErrorsPtr) (nvmlDevice_t, nvmlEccBitType_t, nvmlEccCounterType_t, nvmlEccErrorCounts_t *)

Definition at line 67 of file benchSANVML.c.

nvmlDeviceGetEccModePtr

nvmlReturn_t(* nvmlDeviceGetEccModePtr) (nvmlDevice_t, nvmlEnableState_t *, nvmlEnableState_t *)

Definition at line 68 of file benchSANVML.c.

nvmlDeviceGetFanSpeedPtr

nvmlReturn_t(* nvmlDeviceGetFanSpeedPtr) (nvmlDevice_t, unsigned int *)

Definition at line 69 of file benchSANVML.c.

nvmlDeviceGetHandleByIndexPtr

nvmlReturn_t(* nvmlDeviceGetHandleByIndexPtr) (unsigned int, nvmlDevice_t *)

Definition at line 70 of file benchSANVML.c.

nvmlDeviceGetInforomVersionPtr

nvmlReturn_t(* nvmlDeviceGetInforomVersionPtr) (nvmlDevice_t, nvmlInforomObject_t, char *, unsigned int)

Definition at line 71 of file benchSANVML.c.

nvmlDeviceGetMemoryInfoPtr

nvmlReturn_t(* nvmlDeviceGetMemoryInfoPtr) (nvmlDevice_t, nvmlMemory_t *)

Definition at line 72 of file benchSANVML.c.

nvmlDeviceGetNamePtr

nvmlReturn_t(* nvmlDeviceGetNamePtr) (nvmlDevice_t, char *, unsigned int)

Definition at line 73 of file benchSANVML.c.

nvmlDeviceGetPciInfoPtr

nvmlReturn_t(* nvmlDeviceGetPciInfoPtr) (nvmlDevice_t, nvmlPciInfo_t *)

Definition at line 74 of file benchSANVML.c.

nvmlDeviceGetPerformanceStatePtr

nvmlReturn_t(* nvmlDeviceGetPerformanceStatePtr) (nvmlDevice_t, nvmlPstates_t *)

Definition at line 75 of file benchSANVML.c.

nvmlDeviceGetPowerManagementLimitConstraintsPtr

nvmlReturn_t(* nvmlDeviceGetPowerManagementLimitConstraintsPtr) (nvmlDevice_t device, unsigned int *minLimit, unsigned int *maxLimit)

Definition at line 76 of file benchSANVML.c.

nvmlDeviceGetPowerManagementLimitPtr

nvmlReturn_t(* nvmlDeviceGetPowerManagementLimitPtr) (nvmlDevice_t device, unsigned int *limit)

Definition at line 77 of file benchSANVML.c.

nvmlDeviceGetPowerUsagePtr

nvmlReturn_t(* nvmlDeviceGetPowerUsagePtr) (nvmlDevice_t, unsigned int *)

Definition at line 78 of file benchSANVML.c.

nvmlDeviceGetTemperaturePtr

nvmlReturn_t(* nvmlDeviceGetTemperaturePtr) (nvmlDevice_t, nvmlTemperatureSensors_t, unsigned int *)

Definition at line 79 of file benchSANVML.c.

nvmlDeviceGetTotalEccErrorsPtr

nvmlReturn_t(* nvmlDeviceGetTotalEccErrorsPtr) (nvmlDevice_t, nvmlEccBitType_t, nvmlEccCounterType_t, unsigned long long *)

Definition at line 80 of file benchSANVML.c.

nvmlDeviceGetUtilizationRatesPtr

nvmlReturn_t(* nvmlDeviceGetUtilizationRatesPtr) (nvmlDevice_t, nvmlUtilization_t *)

Definition at line 81 of file benchSANVML.c.

nvmlDeviceSetPowerManagementLimitPtr

nvmlReturn_t(* nvmlDeviceSetPowerManagementLimitPtr) (nvmlDevice_t device, unsigned int limit)

Definition at line 82 of file benchSANVML.c.

nvmlErrorStringPtr

char*(* nvmlErrorStringPtr) (nvmlReturn_t)

Definition at line 64 of file benchSANVML.c.

nvmlInitPtr

nvmlReturn_t(* nvmlInitPtr) (void)

Definition at line 83 of file benchSANVML.c.

nvmlShutdownPtr

nvmlReturn_t(* nvmlShutdownPtr) (void)

Definition at line 84 of file benchSANVML.c.

t2

struct timeval t1 t2

static

Definition at line 117 of file benchSANVML.c.