coretemp_freebsd.c

Go to the documentation of this file.

/****************************/
/* THIS IS OPEN SOURCE CODE */
/****************************/

#include <sys/types.h>
#include <sys/resource.h>
#include <sys/sysctl.h>

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <inttypes.h>

/* Headers required by PAPI */
#include "papi.h"
#include "papi_internal.h"
#include "papi_vector.h"
#include "papi_memory.h"

#define CORETEMP_MAX_COUNTERS 32 /* Can we tune this dynamically? */
#define TRUE  (1==1)
#define FALSE (1!=1)
#define UNREFERENCED(x) (void)x

/* Structure that stores private information for each event */
typedef struct coretemp_register
{
    int mib[4];
    /* Access to registers through these MIBs + sysctl (3) call */
    
    unsigned int selector;
} coretemp_register_t;

typedef struct coretemp_native_event_entry
{
    coretemp_register_t resources;            
    char name[PAPI_MAX_STR_LEN];             
    char description[PAPI_MAX_STR_LEN];      
} coretemp_native_event_entry_t;

/* This structure is used when doing register allocation 
   it possibly is not necessary when there are no 
   register constraints */
typedef struct coretemp_reg_alloc
{
    coretemp_register_t ra_bits;
} coretemp_reg_alloc_t;

/* Holds control flags, usually out-of band configuration of the hardware */
typedef struct coretemp_control_state
{
    int added[CORETEMP_MAX_COUNTERS];
    long_long counters[CORETEMP_MAX_COUNTERS];  
} coretemp_control_state_t;

/* Holds per-thread information */
typedef struct coretemp_context
{
    coretemp_control_state_t state;
} coretemp_context_t;

static coretemp_native_event_entry_t *coretemp_native_table;

static int CORETEMP_NUM_EVENTS = 0;


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

int coretemp_init_thread (hwd_context_t * ctx)
{
    int mib[4];
    size_t len;
    UNREFERENCED(ctx);

    SUBDBG("coretemp_init_thread %p...\n", ctx);

#if 0
    /* what does this do?  VMW */

    len = 4;
    if (sysctlnametomib ("dev.coretemp.0.%driver", mib, &len) == -1)
        return PAPI_ECMP;
#endif

    return PAPI_OK;
}


int coretemp_init_component ()
{
    int ret;
    int i;
    int mib[4];
    size_t len;
    char tmp[128];

    SUBDBG("coretemp_init_component...\n");

    /* Count the number of cores (counters) that have sensors allocated */
    i = 0;
    CORETEMP_NUM_EVENTS = 0;
    sprintf (tmp, "dev.coretemp.%d.%%driver", i);
    len = 4;
    ret = sysctlnametomib (tmp, mib, &len);
    while (ret != -1)
    {
        CORETEMP_NUM_EVENTS++;
        i++;
        sprintf (tmp, "dev.coretemp.%d.%%driver", i);
        len = 4;
        ret = sysctlnametomib (tmp, mib, &len);
    }

    /* Allocate memory for the our event table */
    coretemp_native_table = (coretemp_native_event_entry_t *)
        papi_malloc (sizeof (coretemp_native_event_entry_t) * CORETEMP_NUM_EVENTS);
    if (coretemp_native_table == NULL)
    {
        perror( "malloc():Could not get memory for coretemp events table" );
        return PAPI_ENOMEM;
    }

    /* Allocate native events internal structures */
    for (i = 0; i < CORETEMP_NUM_EVENTS; i++)
    {
        /* Event name */
        sprintf (coretemp_native_table[i].name, "CORETEMP_CPU_%d", i);

        /* Event description */
        sprintf (coretemp_native_table[i].description, "CPU On-Die Thermal Sensor #%d", i);

        /* Event extra bits -> save MIB to faster access later */
        sprintf (tmp, "dev.cpu.%d.temperature", i);
        len = 4;
        if (sysctlnametomib (tmp, coretemp_native_table[i].resources.mib, &len) == -1)
            return PAPI_ECMP;

        coretemp_native_table[i].resources.selector = i+1;
    }

    return PAPI_OK;
}


int coretemp_init_control_state (hwd_control_state_t * ctrl)
{
    int i;

    SUBDBG("coretemp_init_control_state... %p\n", ctrl);
    coretemp_control_state_t *c = (coretemp_control_state_t *) ctrl;

    for (i = 0; i < CORETEMP_MAX_COUNTERS; i++)
        c->added[i] = FALSE;

    return PAPI_OK;
}


int coretemp_ntv_enum_events (unsigned int *EventCode, int modifier)
{

    switch ( modifier )
    {
        /* return EventCode of first event */
        case PAPI_ENUM_FIRST:
        *EventCode = 0;
        return PAPI_OK;
        break;

        /* return EventCode of passed-in Event */
        case PAPI_ENUM_EVENTS:
        {
            int index = *EventCode;

            if ( index < CORETEMP_NUM_EVENTS - 1 )
            {
                *EventCode = *EventCode + 1;
                return PAPI_OK;
            }
            else
                return PAPI_ENOEVNT;
            break;
        }

        default:
            return PAPI_EINVAL;
    }

    return PAPI_EINVAL;
}

int coretemp_ntv_code_to_name (unsigned int EventCode, char *name, int len)
{
    int index = EventCode;

    strncpy( name, coretemp_native_table[index].name, len );

    return PAPI_OK;
}

int coretemp_ntv_code_to_descr (unsigned int EventCode, char *name, int len)
{
    int index = EventCode;

    strncpy( name, coretemp_native_table[index].description, len );

    return PAPI_OK;
}

int coretemp_ntv_code_to_bits (unsigned int EventCode, hwd_register_t * bits)
{
    UNREFERENCED(EventCode);
    UNREFERENCED(bits);

    return PAPI_OK;
}

int coretemp_update_control_state( hwd_control_state_t * ptr,
    NativeInfo_t * native, int count, hwd_context_t * ctx )
{
    int i, index;
    coretemp_control_state_t *c = (coretemp_control_state_t *) ptr;
    UNREFERENCED(ctx);

    SUBDBG("coretemp_update_control_state %p %p...\n", ptr, ctx);

    for (i = 0; i < count; i++)
    {
        index = native[i].ni_event;
        native[i].ni_position = coretemp_native_table[index].resources.selector - 1;
        c->added[native[i].ni_position] = TRUE;

        SUBDBG ("\nnative[%i].ni_position = coretemp_native_table[%i].resources.selector-1 = %i;\n",
          i, index, native[i].ni_position );
    }

    return PAPI_OK;
}

int coretemp_start (hwd_context_t * ctx, hwd_control_state_t * ctrl)
{
    UNREFERENCED(ctx);
    UNREFERENCED(ctrl);

    SUBDBG( "coretemp_start %p %p...\n", ctx, ctrl );

    /* Nothing to be done */

    return PAPI_OK;
}


int coretemp_stop (hwd_context_t * ctx, hwd_control_state_t * ctrl)
{
    UNREFERENCED(ctx);
    UNREFERENCED(ctrl);

    SUBDBG("coretemp_stop %p %p...\n", ctx, ctrl);

    /* Nothing to be done */

    return PAPI_OK;
}


int coretemp_read (hwd_context_t * ctx, hwd_control_state_t * ctrl,
    long_long ** events, int flags)
{
    int i;
    coretemp_control_state_t *c = (coretemp_control_state_t *) ctrl;
    UNREFERENCED(ctx);
    UNREFERENCED(flags);

    SUBDBG("coretemp_read... %p %d\n", ctx, flags);

    for (i = 0; i < CORETEMP_MAX_COUNTERS; i++)
        if (c->added[i])
        {
            int tmp;
            size_t len = sizeof(tmp);

            if (sysctl (coretemp_native_table[i].resources.mib, 4, &tmp, &len, NULL, 0) == -1)
                c->counters[i] = 0;
            else
                c->counters[i] = tmp/10;
                /* Coretemp module returns temperature in tenths of kelvin 
                   Kelvin are useful to avoid negative values... but will have
                   negative temperatures ??? */
        }

    *events = c->counters;

    return PAPI_OK;
}

/*    otherwise, the updated state is written to ESI->hw_start      */
int coretemp_write (hwd_context_t * ctx, hwd_control_state_t * ctrl,
    long_long events[] )
{
    UNREFERENCED(ctx);
    UNREFERENCED(events);
    UNREFERENCED(ctrl);

    SUBDBG("coretemp_write... %p %p\n", ctx, ctrl);

    /* These sensor counters cannot be writtn */

    return PAPI_OK;
}


int coretemp_reset(hwd_context_t * ctx, hwd_control_state_t * ctrl)
{
    UNREFERENCED(ctx);
    UNREFERENCED(ctrl);

    SUBDBG("coretemp_reset ctx=%p ctrl=%p...\n", ctx, ctrl);

    /* These sensors cannot be reseted */

    return PAPI_OK;
}

int coretemp_shutdown_component (void)
{

    SUBDBG( "coretemp_shutdown_component... %p\n", ctx );

    /* Last chance to clean up */
    papi_free (coretemp_native_table);

    return PAPI_OK;
}



int coretemp_ctl (hwd_context_t * ctx, int code, _papi_int_option_t * option)
{
    UNREFERENCED(ctx);
    UNREFERENCED(code);
    UNREFERENCED(option);

    SUBDBG( "coretemp_ctl... %p %d %p\n", ctx, code, option );

    /* FIXME.  This should maybe set up more state, such as which counters are active and */
    /*         counter mappings. */

    return PAPI_OK;
}

int coretemp_set_domain (hwd_control_state_t * cntrl, int domain)
{
    int found = 0;
    UNREFERENCED(cntrl);

    SUBDBG ("coretemp_set_domain... %p %d\n", cntrl, domain);

    if (PAPI_DOM_USER & domain)
    {
        SUBDBG( " PAPI_DOM_USER \n" );
        found = 1;
    }
    if (PAPI_DOM_KERNEL & domain)
    {
        SUBDBG( " PAPI_DOM_KERNEL \n" );
        found = 1;
    }
    if (PAPI_DOM_OTHER & domain)
    {
        SUBDBG( " PAPI_DOM_OTHER \n" );
        found = 1;
    }
    if (PAPI_DOM_ALL & domain)
    {
        SUBDBG( " PAPI_DOM_ALL \n" );
        found = 1;
    }
    if (!found)
        return PAPI_EINVAL ;

    return PAPI_OK;
}


papi_vector_t _coretemp_freebsd_vector = {
    .cmp_info = {
                 /* default component information (unspecified values are initialized to 0) */
                 .name = "coretemp_freebsd",
                 .short_name = "coretemp",
                 .version = "5.0",
                 .num_mpx_cntrs = CORETEMP_MAX_COUNTERS,
                 .num_cntrs = CORETEMP_MAX_COUNTERS,
                 .default_domain = PAPI_DOM_USER,
                 .available_domains = PAPI_DOM_USER,
                 .default_granularity = PAPI_GRN_THR,
                 .available_granularities = PAPI_GRN_THR,
                 .hardware_intr_sig = PAPI_INT_SIGNAL,

                 /* component specific cmp_info initializations */
                 .fast_real_timer = 0,
                 .fast_virtual_timer = 0,
                 .attach = 0,
                 .attach_must_ptrace = 0,
                 }
    ,

    /* sizes of framework-opaque component-private structures */
    .size = {
             .context = sizeof ( coretemp_context_t ),
             .control_state = sizeof ( coretemp_control_state_t ),
             .reg_value = sizeof ( coretemp_register_t ),
             .reg_alloc = sizeof ( coretemp_reg_alloc_t ),
             }
    ,
    /* function pointers in this component */
    .init_thread = coretemp_init_thread,
    .init_component = coretemp_init_component,
    .init_control_state = coretemp_init_control_state,
    .start = coretemp_start,
    .stop = coretemp_stop,
    .read = coretemp_read,
    .write = coretemp_write,
    .shutdown_component = coretemp_shutdown_component,
    .ctl = coretemp_ctl,

    .update_control_state = coretemp_update_control_state,
    .set_domain = coretemp_set_domain,
    .reset = coretemp_reset,

    .ntv_enum_events = coretemp_ntv_enum_events,
    .ntv_code_to_name = coretemp_ntv_code_to_name,
    .ntv_code_to_descr = coretemp_ntv_code_to_descr,
    .ntv_code_to_bits = coretemp_ntv_code_to_bits,
};