/****************************

THIS IS OPEN SOURCE CODE

Part of the PAPI software library. Copyright (c) 2005 - 2017,

Innovative Computing Laboratory, Dept of Electrical Engineering &

Computer Science University of Tennessee, Knoxville, TN.

The open source software license conforms to the 2-clause BSD License

template.

****************************/

/**

 * @file    linux-nvml.c

 * @author  Kiran Kumar Kasichayanula

 *          kkasicha@utk.edu

 * @author  James Ralph

 *          ralph@eecs.utk.edu

 * @ingroup papi_components

 *

 * @brief This is an NVML component, it demos the component interface

 *  and implements a number of counters from the Nvidia Management

 *  Library. Please refer to NVML documentation for details about

 *  nvmlDeviceGetPowerUsage, nvmlDeviceGetTemperature. Power is

 *  reported in mW and temperature in Celcius.  The counter

 *  descriptions should contain the units that the measurement

 *  returns.

 */

#include <dlfcn.h>

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

#include <inttypes.h>

#include <string.h>

/* Headers required by PAPI */

#include "papi.h"

#include "papi_internal.h"

#include "papi_vector.h"

#include "papi_memory.h"

#include "linux-nvml.h"

#include "nvml.h"

#include "cuda.h"

#include "cuda_runtime_api.h"

void (*_dl_non_dynamic_init)(void) __attribute__((weak));

/*****  CHANGE PROTOTYPES TO DECLARE CUDA AND NVML LIBRARY SYMBOLS AS WEAK  *****

 *  This is done so that a version of PAPI built with the nvml component can    *

 *  be installed on a system which does not have the cuda libraries installed.  *

 *                                                                              *

 *  If this is done without these prototypes, then all papi services on the     *

 *  system without the cuda libraries installed will fail.  The PAPI libraries  *

 *  contain references to the cuda libraries which are not installed.  The      *

 *  load of PAPI commands fails because the cuda library references can not be  *

 *  resolved.                                                                   *

 *                                                                              *

 *  This also defines pointers to the cuda library functions that we call.      *

 *  These function pointers will be resolved with dlopen/dlsym calls at         *

 *  component initialization time.  The component then calls the cuda library   *

 *  functions through these function pointers.                                  *

 ********************************************************************************/

#undef CUDAAPI

#define CUDAAPI __attribute__((weak))

CUresult CUDAAPI cuInit(unsigned int);

CUresult(*cuInitPtr)(unsigned int);

#undef CUDARTAPI

#define CUDARTAPI __attribute__((weak))

cudaError_t CUDARTAPI cudaGetDevice(int *);

cudaError_t CUDARTAPI cudaGetDeviceCount(int *);

cudaError_t CUDARTAPI cudaDeviceGetPCIBusId(char *, int, int);

cudaError_t (*cudaGetDevicePtr)(int *);

cudaError_t (*cudaGetDeviceCountPtr)(int *);

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

#undef DECLDIR

#define DECLDIR __attribute__((weak))

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

const char*  DECLDIR nvmlErrorString(nvmlReturn_t);

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

nvmlReturn_t DECLDIR nvmlDeviceGetFanSpeed(nvmlDevice_t, unsigned int *);

nvmlReturn_t DECLDIR nvmlDeviceGetMemoryInfo(nvmlDevice_t, nvmlMemory_t *);

nvmlReturn_t DECLDIR nvmlDeviceGetPerformanceState(nvmlDevice_t, nvmlPstates_t *);

nvmlReturn_t DECLDIR nvmlDeviceGetPowerUsage(nvmlDevice_t, unsigned int *);

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 nvmlDeviceGetHandleByIndex(unsigned int, nvmlDevice_t *);

nvmlReturn_t DECLDIR nvmlDeviceGetPciInfo(nvmlDevice_t, nvmlPciInfo_t *);

nvmlReturn_t DECLDIR nvmlDeviceGetName(nvmlDevice_t, char *, unsigned int);

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

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

nvmlReturn_t DECLDIR nvmlInit(void);

nvmlReturn_t DECLDIR nvmlDeviceGetCount(unsigned int *);

nvmlReturn_t DECLDIR nvmlShutdown(void);

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

nvmlReturn_t DECLDIR nvmlDeviceSetPowerManagementLimit(nvmlDevice_t device, unsigned int  limit);

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

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

char* (*nvmlErrorStringPtr)(nvmlReturn_t);

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

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

nvmlReturn_t (*nvmlDeviceGetMemoryInfoPtr)(nvmlDevice_t, nvmlMemory_t *);

nvmlReturn_t (*nvmlDeviceGetPerformanceStatePtr)(nvmlDevice_t, nvmlPstates_t *);

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 (*nvmlDeviceGetHandleByIndexPtr)(unsigned int, nvmlDevice_t *);

nvmlReturn_t (*nvmlDeviceGetPciInfoPtr)(nvmlDevice_t, nvmlPciInfo_t *);

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

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

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

nvmlReturn_t (*nvmlInitPtr)(void);

nvmlReturn_t (*nvmlDeviceGetCountPtr)(unsigned int *);

nvmlReturn_t (*nvmlShutdownPtr)(void);

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

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

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

// file handles used to access cuda libraries with dlopen

static void* dl1 = NULL;

static void* dl2 = NULL;

static void* dl3 = NULL;

static int linkCudaLibraries();

/* Declare our vector in advance */

papi_vector_t _nvml_vector;

/* upto 25 events per card how many cards per system should we allow for?! */

#define NVML_MAX_COUNTERS 100

/** Holds control flags.  Usually there's one of these per event-set.

 *    Usually this is out-of band configuration of the hardware

 */

typedef struct nvml_control_state {

    int num_events;

    int which_counter[NVML_MAX_COUNTERS];

    long long counter[NVML_MAX_COUNTERS];   /**< Copy of counts, holds results when stopped */

} nvml_control_state_t;

/** Holds per-thread information */

typedef struct nvml_context {

    nvml_control_state_t state;

} nvml_context_t;

/** This table contains the native events */

static nvml_native_event_entry_t *nvml_native_table = NULL;

/** Number of devices detected at component_init time */

static int device_count = 0;

/** number of events in the table*/

static int num_events = 0;

static nvmlDevice_t* devices = NULL;

static int* features = NULL;

static unsigned int *power_management_initial_limit = NULL;

static unsigned int *power_management_limit_constraint_min = NULL;

static unsigned int *power_management_limit_constraint_max = NULL;

unsigned long long

getClockSpeed(nvmlDevice_t dev, nvmlClockType_t which_one)

{

    unsigned int ret = 0;

    nvmlReturn_t bad;

    bad = (*nvmlDeviceGetClockInfoPtr)(dev, which_one, &ret;;

    if (NVML_SUCCESS != bad) {

        SUBDBG("something went wrong %s\n", (*nvmlErrorStringPtr)(bad));

    }

    return (unsigned long long)ret;

}

unsigned long long

getEccLocalErrors(nvmlDevice_t dev, nvmlEccBitType_t bits, int which_one)

{

    nvmlEccErrorCounts_t counts;

    nvmlReturn_t bad;

    bad = (*nvmlDeviceGetDetailedEccErrorsPtr)(dev, bits, NVML_VOLATILE_ECC , &counts);

    if (NVML_SUCCESS != bad) {

        SUBDBG("something went wrong %s\n", (*nvmlErrorStringPtr)(bad));

    }

    switch (which_one) {

    case LOCAL_ECC_REGFILE:

        return counts.registerFile;

    case LOCAL_ECC_L1:

        return counts.l1Cache;

    case LOCAL_ECC_L2:

        return counts.l2Cache;

    case LOCAL_ECC_MEM:

        return counts.deviceMemory;

    default:

        ;

    }

    return (unsigned long long) - 1;

}

unsigned long long

getFanSpeed(nvmlDevice_t dev)

{

    unsigned int ret = 0;

    nvmlReturn_t bad;

    bad = (*nvmlDeviceGetFanSpeedPtr)(dev, &ret;;

    if (NVML_SUCCESS != bad) {

        SUBDBG("something went wrong %s\n", (*nvmlErrorStringPtr)(bad));

    }

    return (unsigned long long)ret;

}

unsigned long long

getMaxClockSpeed(nvmlDevice_t dev, nvmlClockType_t which_one)

{

    unsigned int ret = 0;

    nvmlReturn_t bad;

    bad = (*nvmlDeviceGetClockInfoPtr)(dev, which_one, &ret;;

    if (NVML_SUCCESS != bad) {

        SUBDBG("something went wrong %s\n", (*nvmlErrorStringPtr)(bad));

    }

    return (unsigned long long) ret;

}

unsigned long long

getMemoryInfo(nvmlDevice_t dev, int which_one)

{

    nvmlMemory_t meminfo;

    nvmlReturn_t bad;

    bad = (*nvmlDeviceGetMemoryInfoPtr)(dev, &meminfo);

    if (NVML_SUCCESS != bad) {

        SUBDBG("something went wrong %s\n", (*nvmlErrorStringPtr)(bad));

    }

    switch (which_one) {

    case MEMINFO_TOTAL_MEMORY:

        return meminfo.total;

    case MEMINFO_UNALLOCED:

        return meminfo.free;

    case MEMINFO_ALLOCED:

        return meminfo.used;

    default:

        ;

    }

    return (unsigned long long) - 1;

}

unsigned long long

getPState(nvmlDevice_t dev)

{

    unsigned int ret = 0;

    nvmlPstates_t state = NVML_PSTATE_15;

    nvmlReturn_t bad;

    bad = (*nvmlDeviceGetPerformanceStatePtr)(dev, &state);

    if (NVML_SUCCESS != bad) {

        SUBDBG("something went wrong %s\n", (*nvmlErrorStringPtr)(bad));

    }

    switch (state) {

    case NVML_PSTATE_15:

        ret++;

    case NVML_PSTATE_14:

        ret++;

    case NVML_PSTATE_13:

        ret++;

    case NVML_PSTATE_12:

        ret++;

    case NVML_PSTATE_11:

        ret++;

    case NVML_PSTATE_10:

        ret++;

    case NVML_PSTATE_9:

        ret++;

    case NVML_PSTATE_8:

        ret++;

    case NVML_PSTATE_7:

        ret++;

    case NVML_PSTATE_6:

        ret++;

    case NVML_PSTATE_5:

        ret++;

    case NVML_PSTATE_4:

        ret++;

    case NVML_PSTATE_3:

        ret++;

    case NVML_PSTATE_2:

        ret++;

    case NVML_PSTATE_1:

        ret++;

    case NVML_PSTATE_0:

        break;

    case NVML_PSTATE_UNKNOWN:

    default:

        /* This should never happen?

         * The API docs just state Unknown performance state... */

        return (unsigned long long) - 1;

    }

    return (unsigned long long)ret;

}

unsigned long long

getPowerUsage(nvmlDevice_t dev)

{

    unsigned int power;

    nvmlReturn_t bad;

    bad = (*nvmlDeviceGetPowerUsagePtr)(dev, &power);

    if (NVML_SUCCESS != bad) {

        SUBDBG("something went wrong %s\n", (*nvmlErrorStringPtr)(bad));

    }

    return (unsigned long long) power;

}

unsigned long long

getTemperature(nvmlDevice_t dev)

{

    unsigned int ret = 0;

    nvmlReturn_t bad;

    bad = (*nvmlDeviceGetTemperaturePtr)(dev, NVML_TEMPERATURE_GPU, &ret;;

    if (NVML_SUCCESS != bad) {

        SUBDBG("something went wrong %s\n", (*nvmlErrorStringPtr)(bad));

    }

    return (unsigned long long)ret;

}

unsigned long long

getTotalEccErrors(nvmlDevice_t dev, nvmlEccBitType_t bits)

{

    unsigned long long counts = 0;

    nvmlReturn_t bad;

    bad = (*nvmlDeviceGetTotalEccErrorsPtr)(dev, bits, NVML_VOLATILE_ECC , &counts);

    if (NVML_SUCCESS != bad) {

        SUBDBG("something went wrong %s\n", (*nvmlErrorStringPtr)(bad));

    }

    return counts;

}

/*  0 => gpu util

    1 => memory util

 */

unsigned long long

getUtilization(nvmlDevice_t dev, int which_one)

{

    nvmlUtilization_t util;

    nvmlReturn_t bad;

    bad = (*nvmlDeviceGetUtilizationRatesPtr)(dev, &util);

    if (NVML_SUCCESS != bad) {

        SUBDBG("something went wrong %s\n", (*nvmlErrorStringPtr)(bad));

    }

    switch (which_one) {

    case GPU_UTILIZATION:

        return (unsigned long long) util.gpu;

    case MEMORY_UTILIZATION:

        return (unsigned long long) util.memory;

    default:

        ;

    }

    return (unsigned long long) - 1;

}

unsigned long long getPowerManagementLimit(nvmlDevice_t dev)

{

    unsigned int limit;

    nvmlReturn_t rv;

    rv = (*nvmlDeviceGetPowerManagementLimitPtr)(dev, &limit);

    if (NVML_SUCCESS != rv) {

        SUBDBG("something went wrong %s\n", (*nvmlErrorStringPtr)(rv));

        return (unsigned long long) 0;

    }

    return (unsigned long long) limit;

}

static void

nvml_hardware_reset()

{

    /* nvmlDeviceSet* and nvmlDeviceClear* calls require root/admin access, so while

     * possible to implement a reset on the ECC counters, we pass */

    /*

       for ( i=0; i < device_count; i++ )

       nvmlDeviceClearEccErrorCounts( device[i], NVML_VOLATILE_ECC );

    */

    int i;

    nvmlReturn_t ret;

    unsigned int templimit = 0;

    for (i = 0; i < device_count; i++) {

        if (HAS_FEATURE(features[i], FEATURE_POWER_MANAGEMENT)) {

            // if power management is available

            if (power_management_initial_limit[i] != 0) {

                ret = (*nvmlDeviceGetPowerManagementLimitPtr)(devices[i], &templimit);

                if ((ret == NVML_SUCCESS) && (templimit != power_management_initial_limit[i])) {

                    SUBDBG("Reset power_management_limit on device %d to initial value of %d \n", i, power_management_initial_limit[i]);

                    // if power is not at its initial value

                    // reset to initial value

                    ret = (*nvmlDeviceSetPowerManagementLimitPtr)(devices[i], power_management_initial_limit[i]);

                    if (ret != NVML_SUCCESS)

                        SUBDBG("Unable to reset the NVML power management limit on device %i to %ull (return code %d) \n", i, power_management_initial_limit[i] , ret);

                }

            }

        }

    }

}

/** Code that reads event values.                         */

/*   You might replace this with code that accesses       */

/*   hardware or reads values from the operatings system. */

static int

nvml_hardware_read(long long *value, int which_one)

//, nvml_context_t *ctx)

{

    nvml_native_event_entry_t *entry;

    nvmlDevice_t handle;

    int cudaIdx = -1;

    entry = &nvml_native_table[which_one];

    *value = (long long) - 1;

    /* replace entry->resources with the current cuda_device->nvml device */

    (*cudaGetDevicePtr)(&cudaIdx);

    if (cudaIdx < 0 || cudaIdx > device_count)

        return PAPI_EINVAL;

    /* Make sure the device we are running on has the requested event */

    if (!HAS_FEATURE(features[cudaIdx] , entry->type))

        return PAPI_EINVAL;

    handle = devices[cudaIdx];

    switch (entry->type) {

    case FEATURE_CLOCK_INFO:

        *value =  getClockSpeed(handle, (nvmlClockType_t)entry->options.clock);

        break;

    case FEATURE_ECC_LOCAL_ERRORS:

        *value = getEccLocalErrors(handle,

                                   (nvmlEccBitType_t)entry->options.ecc_opts.bits,

                                   (int)entry->options.ecc_opts.which_one);

        break;

    case FEATURE_FAN_SPEED:

        *value = getFanSpeed(handle);

        break;

    case FEATURE_MAX_CLOCK:

        *value = getMaxClockSpeed(handle,

                                  (nvmlClockType_t)entry->options.clock);

        break;

    case FEATURE_MEMORY_INFO:

        *value = getMemoryInfo(handle,

                               (int)entry->options.which_one);

        break;

    case FEATURE_PERF_STATES:

        *value = getPState(handle);

        break;

    case FEATURE_POWER:

        *value = getPowerUsage(handle);

        break;

    case FEATURE_TEMP:

        *value = getTemperature(handle);

        break;

    case FEATURE_ECC_TOTAL_ERRORS:

        *value = getTotalEccErrors(handle,

                                   (nvmlEccBitType_t)entry->options.ecc_opts.bits);

        break;

    case FEATURE_UTILIZATION:

        *value = getUtilization(handle,

                                (int)entry->options.which_one);

        break;

    case FEATURE_POWER_MANAGEMENT:

        *value = getPowerManagementLimit(handle);

        break;

    case FEATURE_NVML_POWER_MANAGEMENT_LIMIT_CONSTRAINT_MIN:

        *value = power_management_limit_constraint_min[cudaIdx];

        break;

    case FEATURE_NVML_POWER_MANAGEMENT_LIMIT_CONSTRAINT_MAX:

        *value = power_management_limit_constraint_max[cudaIdx];

        break;

    default:

        return PAPI_EINVAL;

    }

    return PAPI_OK;

}

/** Code that reads event values.                         */

/*   You might replace this with code that accesses       */

/*   hardware or reads values from the operatings system. */

static int nvml_hardware_write(long long *value, int which_one)

{

    nvml_native_event_entry_t *entry;

    nvmlDevice_t handle;

    int cudaIdx = -1;

    nvmlReturn_t nvret;

    entry = &nvml_native_table[which_one];

    /* replace entry->resources with the current cuda_device->nvml device */

    (*cudaGetDevicePtr)(&cudaIdx);

    if (cudaIdx < 0 || cudaIdx > device_count)

        return PAPI_EINVAL;

    /* Make sure the device we are running on has the requested event */

    if (!HAS_FEATURE(features[cudaIdx] , entry->type))

        return PAPI_EINVAL;

    handle = devices[cudaIdx];

    switch (entry->type) {

    case FEATURE_POWER_MANAGEMENT: {

        unsigned int setToPower = (unsigned int) * value;

        if (setToPower < power_management_limit_constraint_min[cudaIdx]) {

            SUBDBG("Error: Desired power %u mW < minimum %u mW on device %d\n", setToPower, power_management_limit_constraint_min[cudaIdx], cudaIdx);

            return PAPI_EINVAL;

        }

        if (setToPower > power_management_limit_constraint_max[cudaIdx]) {

            SUBDBG("Error: Desired power %u mW > maximum %u mW on device %d\n", setToPower, power_management_limit_constraint_max[cudaIdx], cudaIdx);

            return PAPI_EINVAL;

        }

        if ((nvret = (*nvmlDeviceSetPowerManagementLimitPtr)(handle, setToPower)) != NVML_SUCCESS) {

            SUBDBG("Error: %s\n", (*nvmlErrorStringPtr)(nvret));

            return PAPI_EINVAL;

        }

    }

    break;

    default:

        return PAPI_EINVAL;

    }

    return PAPI_OK;

}

/********************************************************************/

/* Below are the functions required by the PAPI component interface */

/********************************************************************/

/** This is called whenever a thread is initialized */

int

_papi_nvml_init_thread(hwd_context_t * ctx)

{

    (void) ctx;

    SUBDBG("Enter: ctx: %p\n", ctx);

    return PAPI_OK;

}

static int

detectDevices()

{

    nvmlReturn_t ret;

    nvmlEnableState_t mode = NVML_FEATURE_DISABLED;

    char name[64];

    char inforomECC[16];

    char inforomPower[16];

    char names[device_count][64];

    float ecc_version = 0.0;

    float power_version = 0.0;

    int i = 0;

    int isTesla = 0;

    int isFermi = 0;

    unsigned int temp = 0;

    memset(names, 0x0, device_count * 64);

    /* So for each card, check whats querable */

    for (i = 0; i < device_count; i++) {

        isTesla = 0;

        isFermi = 1;

        features[i] = 0;

        ret = (*nvmlDeviceGetHandleByIndexPtr)(i, &devices[i]);

        if (NVML_SUCCESS != ret) {

            SUBDBG("nvmlDeviceGetHandleByIndex(%d, &devices[%d]) failed.\n", i, i);

            return PAPI_ESYS;

        }

        ret = (*nvmlDeviceGetNamePtr)(devices[i], name, sizeof(name) - 1);

        if (NVML_SUCCESS != ret) {

            SUBDBG("nvmlDeviceGetName failed \n");

            strncpy(name, "deviceNameUnknown", 17);

        }

        name[sizeof(name) - 1] = '\0';   // to safely use strstr operation below, the variable 'name' must be null terminated

        ret = (*nvmlDeviceGetInforomVersionPtr)(devices[i], NVML_INFOROM_ECC, inforomECC, 16);

        if (NVML_SUCCESS != ret) {

            SUBDBG("nvmlGetInforomVersion fails %s\n", (*nvmlErrorStringPtr)(ret));

            isFermi = 0;

        }

        ret = (*nvmlDeviceGetInforomVersionPtr)(devices[i], NVML_INFOROM_POWER, inforomPower, 16);

        if (NVML_SUCCESS != ret) {

            /* This implies the card is older then Fermi */

            SUBDBG("nvmlGetInforomVersion fails %s\n", (*nvmlErrorStringPtr)(ret));

            SUBDBG("Based upon the return to nvmlGetInforomVersion, we conclude this card is older then Fermi.\n");

            isFermi = 0;

        }

        ecc_version = strtof(inforomECC, NULL);

        power_version = strtof(inforomPower, NULL);

        isTesla = (NULL == strstr(name, "Tesla")) ? 0 : 1;

        /* For Tesla and Quadro products from Fermi and Kepler families. */

        if (isFermi) {

            features[i] |= FEATURE_CLOCK_INFO;

            num_events += 3;

        }

        /*  For Tesla and Quadro products from Fermi and Kepler families.

            requires NVML_INFOROM_ECC 2.0 or higher for location-based counts

            requires NVML_INFOROM_ECC 1.0 or higher for all other ECC counts

            requires ECC mode to be enabled. */

        ret = (*nvmlDeviceGetEccModePtr)(devices[i], &mode, NULL);

        if (NVML_SUCCESS == ret) {

            if (NVML_FEATURE_ENABLED == mode) {

                if (ecc_version >= 2.0) {

                    features[i] |= FEATURE_ECC_LOCAL_ERRORS;

                    num_events += 8; /* {single bit, two bit errors} x { reg, l1, l2, memory } */

                }

                if (ecc_version >= 1.0) {

                    features[i] |= FEATURE_ECC_TOTAL_ERRORS;

                    num_events += 2; /* single bit errors, double bit errors */

                }

            }

        } else {

            SUBDBG("nvmlDeviceGetEccMode does not appear to be supported. (nvml return code %d)\n", ret);

        }

        /* For all discrete products with dedicated fans */

        features[i] |= FEATURE_FAN_SPEED;

        num_events++;

        /* For Tesla and Quadro products from Fermi and Kepler families. */

        if (isFermi) {

            features[i] |= FEATURE_MAX_CLOCK;

            num_events += 3;

        }

        /* For all products */

        features[i] |= FEATURE_MEMORY_INFO;

        num_events += 3; /* total, free, used */

        /* For Tesla and Quadro products from the Fermi and Kepler families. */

        if (isFermi) {

            features[i] |= FEATURE_PERF_STATES;

            num_events++;

        }

        /*  For "GF11x" Tesla and Quadro products from the Fermi family

                requires NVML_INFOROM_POWER 3.0 or higher

                For Tesla and Quadro products from the Kepler family

                does not require NVML_INFOROM_POWER */

        /* Just try reading power, if it works, enable it*/

        ret = (*nvmlDeviceGetPowerUsagePtr)(devices[i], &temp);

        if (NVML_SUCCESS == ret) {

            features[i] |= FEATURE_POWER;

            num_events++;

        } else {

            SUBDBG("nvmlDeviceGetPowerUsage does not appear to be supported on this card. (nvml return code %d)\n", ret);

        }

        /* For all discrete and S-class products. */

        features[i] |= FEATURE_TEMP;

        num_events++;

        // For power_management_limit

        {

            // Just try the call to see if it works

            unsigned int templimit = 0;

            ret = (*nvmlDeviceGetPowerManagementLimitPtr)(devices[i], &templimit);

            if (ret == NVML_SUCCESS && templimit > 0) {

                power_management_initial_limit[i] = templimit;

                features[i] |= FEATURE_POWER_MANAGEMENT;

                num_events += 1;

            } else {

                power_management_initial_limit[i] = 0;

                SUBDBG("nvmlDeviceGetPowerManagementLimit not appear to be supported on this card. (NVML code %d)\n", ret);

            }

        }

        // For power_management_limit_constraints, minimum and maximum

        {

            unsigned int minLimit = 0, maxLimit = 0;

            ret = (*nvmlDeviceGetPowerManagementLimitConstraintsPtr)(devices[i], &minLimit, &maxLimit);

            if (ret == NVML_SUCCESS) {

                power_management_limit_constraint_min[i] = minLimit;

                features[i] |= FEATURE_NVML_POWER_MANAGEMENT_LIMIT_CONSTRAINT_MIN;

                num_events += 1;

                power_management_limit_constraint_max[i] = maxLimit;

                features[i] |= FEATURE_NVML_POWER_MANAGEMENT_LIMIT_CONSTRAINT_MAX;

                num_events += 1;

            } else {

                power_management_limit_constraint_min[i] = 0;

                power_management_limit_constraint_max[i] = INT_MAX;

            }

            SUBDBG("Done nvmlDeviceGetPowerManagementLimitConstraintsPtr\n");

        }

        /* For Tesla and Quadro products from the Fermi and Kepler families */

        if (isFermi) {

            features[i] |= FEATURE_UTILIZATION;

            num_events += 2;

        }

        int retval = snprintf(names[i], sizeof(name), "%s:device:%d", name, i);

        if (retval > (int)sizeof(name)) {

            SUBDBG("Device name is too long %s:device%d", name, i);

            return (PAPI_EINVAL);

        }

        names[i][sizeof(name) - 1] = '\0';

    }

    return PAPI_OK;

}

static void

createNativeEvents()

{

    char name[64];

    char sanitized_name[PAPI_MAX_STR_LEN];

    char names[device_count][64];

    int i, nameLen = 0, j;

    nvml_native_event_entry_t* entry;

    nvmlReturn_t ret;

    nvml_native_table = (nvml_native_event_entry_t*) papi_malloc(

                            sizeof(nvml_native_event_entry_t) * num_events);

    memset(nvml_native_table, 0x0, sizeof(nvml_native_event_entry_t) * num_events);

    entry = &nvml_native_table[0];

    for (i = 0; i < device_count; i++) {

        memset(names[i], 0x0, 64);

        ret = (*nvmlDeviceGetNamePtr)(devices[i], name, sizeof(name) - 1);

        if (NVML_SUCCESS != ret) {

            SUBDBG("nvmlDeviceGetName failed \n");

            strncpy(name, "deviceNameUnknown", 17);

        }

        name[sizeof(name) - 1] = '\0';   // to safely use strlen operation below, the variable 'name' must be null terminated

        nameLen = strlen(name);

        strncpy(sanitized_name, name, PAPI_MAX_STR_LEN);

        int retval = snprintf(sanitized_name, sizeof(name), "%s:device_%d", name, i);

        if (retval > (int)sizeof(name)) {

            SUBDBG("Device name is too long %s:device%d", name, i);

            return;

        }

        sanitized_name[sizeof(name) - 1] = '\0';

        for (j = 0; j < nameLen; j++)

            if (' ' == sanitized_name[j])

                sanitized_name[j] = '_';

        if (HAS_FEATURE(features[i], FEATURE_CLOCK_INFO)) {

            sprintf(entry->name, "%s:graphics_clock", sanitized_name);

            strncpy(entry->description, "Graphics clock domain (MHz).", PAPI_MAX_STR_LEN);

            entry->options.clock = NVML_CLOCK_GRAPHICS;

            entry->type = FEATURE_CLOCK_INFO;

            entry++;

            sprintf(entry->name, "%s:sm_clock", sanitized_name);

            strncpy(entry->description, "SM clock domain (MHz).", PAPI_MAX_STR_LEN);

            entry->options.clock = NVML_CLOCK_SM;

            entry->type = FEATURE_CLOCK_INFO;

            entry++;

            sprintf(entry->name, "%s:memory_clock", sanitized_name);

            strncpy(entry->description, "Memory clock domain (MHz).", PAPI_MAX_STR_LEN);

            entry->options.clock = NVML_CLOCK_MEM;

            entry->type = FEATURE_CLOCK_INFO;

            entry++;

        }

        if (HAS_FEATURE(features[i], FEATURE_ECC_LOCAL_ERRORS)) {

            sprintf(entry->name, "%s:l1_single_ecc_errors", sanitized_name);

            strncpy(entry->description, "L1 cache single bit ECC", PAPI_MAX_STR_LEN);

            entry->options.ecc_opts = (struct local_ecc) {

                .bits = NVML_SINGLE_BIT_ECC,

                 .which_one = LOCAL_ECC_L1,

            };

            entry->type = FEATURE_ECC_LOCAL_ERRORS;

            entry++;

            sprintf(entry->name, "%s:l2_single_ecc_errors", sanitized_name);

            strncpy(entry->description, "L2 cache single bit ECC", PAPI_MAX_STR_LEN);

            entry->options.ecc_opts = (struct local_ecc) {

                .bits = NVML_SINGLE_BIT_ECC,

                 .which_one = LOCAL_ECC_L2,

            };

            entry->type = FEATURE_ECC_LOCAL_ERRORS;

            entry++;

            sprintf(entry->name, "%s:memory_single_ecc_errors", sanitized_name);

            strncpy(entry->description, "Device memory single bit ECC", PAPI_MAX_STR_LEN);

            entry->options.ecc_opts = (struct local_ecc) {

                .bits = NVML_SINGLE_BIT_ECC,

                 .which_one = LOCAL_ECC_MEM,

            };

            entry->type = FEATURE_ECC_LOCAL_ERRORS;

            entry++;

            sprintf(entry->name, "%s:regfile_single_ecc_errors", sanitized_name);

            strncpy(entry->description, "Register file single bit ECC", PAPI_MAX_STR_LEN);

            entry->options.ecc_opts = (struct local_ecc) {

                .bits = NVML_SINGLE_BIT_ECC,

                 .which_one = LOCAL_ECC_REGFILE,

            };

            entry->type = FEATURE_ECC_LOCAL_ERRORS;

            entry++;

            sprintf(entry->name, "%s:1l_double_ecc_errors", sanitized_name);

            strncpy(entry->description, "L1 cache double bit ECC", PAPI_MAX_STR_LEN);

            entry->options.ecc_opts = (struct local_ecc) {

                .bits = NVML_DOUBLE_BIT_ECC,

                 .which_one = LOCAL_ECC_L1,

            };

            entry->type = FEATURE_ECC_LOCAL_ERRORS;

            entry++;

            sprintf(entry->name, "%s:l2_double_ecc_errors", sanitized_name);

            strncpy(entry->description, "L2 cache double bit ECC", PAPI_MAX_STR_LEN);

            entry->options.ecc_opts = (struct local_ecc) {

                .bits = NVML_DOUBLE_BIT_ECC,

                 .which_one = LOCAL_ECC_L2,

            };

            entry->type = FEATURE_ECC_LOCAL_ERRORS;

            entry++;

            sprintf(entry->name, "%s:memory_double_ecc_errors", sanitized_name);

            strncpy(entry->description, "Device memory double bit ECC", PAPI_MAX_STR_LEN);

            entry->options.ecc_opts = (struct local_ecc) {

                .bits = NVML_DOUBLE_BIT_ECC,

                 .which_one = LOCAL_ECC_MEM,

            };

            entry->type = FEATURE_ECC_LOCAL_ERRORS;

            entry++;

            sprintf(entry->name, "%s:regfile_double_ecc_errors", sanitized_name);

            strncpy(entry->description, "Register file double bit ECC", PAPI_MAX_STR_LEN);

            entry->options.ecc_opts = (struct local_ecc) {

                .bits = NVML_DOUBLE_BIT_ECC,

                 .which_one = LOCAL_ECC_REGFILE,

            };

            entry->type = FEATURE_ECC_LOCAL_ERRORS;

            entry++;

        }

        if (HAS_FEATURE(features[i], FEATURE_FAN_SPEED)) {

            sprintf(entry->name, "%s:fan_speed", sanitized_name);

            strncpy(entry->description, "The fan speed expressed as a percent of the maximum, i.e. full speed is 100%", PAPI_MAX_STR_LEN);

            entry->type = FEATURE_FAN_SPEED;

            entry++;

        }

        if (HAS_FEATURE(features[i], FEATURE_MAX_CLOCK)) {

            sprintf(entry->name, "%s:graphics_max_clock", sanitized_name);

            strncpy(entry->description, "Maximal Graphics clock domain (MHz).", PAPI_MAX_STR_LEN);

            entry->options.clock = NVML_CLOCK_GRAPHICS;