linux-stealtime.c File Reference

A component that gather info on VM stealtime. More...

Include dependency graph for linux-stealtime.c:

Go to the source code of this file.

Data Structures
struct	STEALTIME_reg_alloc_t
struct	STEALTIME_control_state
struct	STEALTIME_context
struct	statinfo

Functions
static int	read_stealtime (struct STEALTIME_context *context, int starting)
static int	_stealtime_shutdown_component (void)
static int	_stealtime_init_component (int cidx)
static int	_stealtime_init_thread (hwd_context_t *ctx)
static int	_stealtime_shutdown_thread (hwd_context_t *ctx)
static int	_stealtime_init_control_state (hwd_control_state_t *ctl)
static int	_stealtime_update_control_state (hwd_control_state_t *ctl, NativeInfo_t *native, int count, hwd_context_t *ctx)
static int	_stealtime_start (hwd_context_t *ctx, hwd_control_state_t *ctl)
static int	_stealtime_stop (hwd_context_t *ctx, hwd_control_state_t *ctl)
static int	_stealtime_read (hwd_context_t *ctx, hwd_control_state_t *ctl, long long **events, int flags)
static int	_stealtime_reset (hwd_context_t *ctx, hwd_control_state_t *ctrl)
static int	_stealtime_ctl (hwd_context_t *ctx, int code, _papi_int_option_t *option)
static int	_stealtime_set_domain (hwd_control_state_t *cntrl, int domain)
static int	_stealtime_ntv_code_to_name (unsigned int EventCode, char *name, int len)
static int	_stealtime_ntv_code_to_descr (unsigned int EventCode, char *name, int len)
static int	_stealtime_ntv_code_to_info (unsigned int EventCode, PAPI_event_info_t *info)
static int	_stealtime_ntv_enum_events (unsigned int *EventCode, int modifier)

Variables
static int	num_events = 0
static struct counter_info *	event_info =NULL
papi_vector_t	_stealtime_vector

Detailed Description

Author

Vince Weaver vweav.nosp@m.er1@.nosp@m.eecs..nosp@m.utk..nosp@m.edu

Definition in file linux-stealtime.c.

Function Documentation

_stealtime_ctl()

static int _stealtime_ctl ( hwd_context_t *  ctx, int  code, _papi_int_option_t *  option  )

static

Definition at line 449 of file linux-stealtime.c.

{
    ( void ) ctx;
    ( void ) code;
    ( void ) option;

    return PAPI_OK;
}

_stealtime_init_component()

static int _stealtime_init_component ( int  cidx )

static

Definition at line 137 of file linux-stealtime.c.

{

  (void)cidx;

    FILE *fff;
    char buffer[BUFSIZ],*result,string[BUFSIZ];
    int i;

    /* Make sure /proc/stat exists */
    fff=fopen("/proc/stat","r");
    if (fff==NULL) {
       strncpy(_stealtime_vector.cmp_info.disabled_reason,
           "Cannot open /proc/stat",PAPI_MAX_STR_LEN);
       _stealtime_shutdown_component();
       return PAPI_ESYS;
    }

    num_events=0;
    while(1) {
      result=fgets(buffer,BUFSIZ,fff);
      if (result==NULL) break;

      /* /proc/stat line with cpu stats always starts with "cpu" */

      if (!strncmp(buffer,"cpu",3)) {
         num_events++;
      }
      else {
        break;
      }

    }

    fclose(fff);

    if (num_events<1) {
       strncpy(_stealtime_vector.cmp_info.disabled_reason,
           "Cannot find enough CPU lines in /proc/stat",
           PAPI_MAX_STR_LEN);
       _stealtime_shutdown_component();
       return PAPI_ESYS;
    }

    event_info=calloc(num_events,sizeof(struct counter_info));
    if (event_info==NULL) {
        _stealtime_shutdown_component();
       return PAPI_ENOMEM;
    }

    
    sysconf(_SC_CLK_TCK);
    event_info[0].name=strdup("TOTAL");
    event_info[0].description=strdup("Total amount of steal time");
    event_info[0].units=strdup("us");

    for(i=1;i<num_events;i++) {
       sprintf(string,"CPU%d",i);
       event_info[i].name=strdup(string);
       sprintf(string,"Steal time for CPU %d",i);
       event_info[i].description=strdup(string);
       event_info[i].units=strdup("us");
        }

    //  printf("Found %d CPUs\n",num_events-1);

    _stealtime_vector.cmp_info.num_native_events=num_events;
    _stealtime_vector.cmp_info.num_cntrs=num_events;
    _stealtime_vector.cmp_info.num_mpx_cntrs=num_events;

    return PAPI_OK;
}

Here is the call graph for this function:

_stealtime_init_control_state()

static int _stealtime_init_control_state ( hwd_control_state_t *  ctl )

static

Definition at line 277 of file linux-stealtime.c.

{

    struct STEALTIME_control_state *control = 
      (struct STEALTIME_control_state *)ctl;

    control->values=NULL;
    control->which_counter=NULL;
    control->num_events=0;

    return PAPI_OK;
}

_stealtime_init_thread()

static int _stealtime_init_thread ( hwd_context_t *  ctx )

static

Definition at line 218 of file linux-stealtime.c.

{
  struct STEALTIME_context *context=(struct STEALTIME_context *)ctx;

  context->start_count=calloc(num_events,sizeof(long long));
  if (context->start_count==NULL) return PAPI_ENOMEM;

  context->current_count=calloc(num_events,sizeof(long long));
  if (context->current_count==NULL) return PAPI_ENOMEM;

  context->value=calloc(num_events,sizeof(long long));
  if (context->value==NULL) return PAPI_ENOMEM;

  return PAPI_OK;
}

_stealtime_ntv_code_to_descr()

static int _stealtime_ntv_code_to_descr ( unsigned int  EventCode, char *  name, int  len  )

static

Definition at line 512 of file linux-stealtime.c.

{

  int event=EventCode;

  if (event >=0 && event < num_events) {
    strncpy( name, event_info[event].description, len );
    return PAPI_OK;
  }

  return PAPI_ENOEVNT;
}

_stealtime_ntv_code_to_info()

static int _stealtime_ntv_code_to_info ( unsigned int  EventCode, PAPI_event_info_t *  info  )

static

Definition at line 528 of file linux-stealtime.c.

{

  int index = EventCode;

  if ( ( index < 0) || (index >= num_events )) return PAPI_ENOEVNT;

  strncpy( info->symbol, event_info[index].name,sizeof(info->symbol));
  info->symbol[sizeof(info->symbol)-1] = '\0';

  strncpy( info->long_descr, event_info[index].description,sizeof(info->symbol));
  info->long_descr[sizeof(info->symbol)-1] = '\0';

  strncpy( info->units, event_info[index].units,sizeof(info->units));
  info->units[sizeof(info->units)-1] = '\0';

  return PAPI_OK;

}

_stealtime_ntv_code_to_name()

static int _stealtime_ntv_code_to_name ( unsigned int  EventCode, char *  name, int  len  )

static

Definition at line 494 of file linux-stealtime.c.

{

  int event=EventCode;

  if (event >=0 && event < num_events) {
     strncpy( name, event_info[event].name, len );
     return PAPI_OK;
  }

  return PAPI_ENOEVNT;
}

_stealtime_ntv_enum_events()

static int _stealtime_ntv_enum_events ( unsigned int *  EventCode, int  modifier  )

static

Definition at line 555 of file linux-stealtime.c.

{

     if ( modifier == PAPI_ENUM_FIRST ) {
    if (num_events==0) return PAPI_ENOEVNT;
    *EventCode = 0;
    return PAPI_OK;
     }

     if ( modifier == PAPI_ENUM_EVENTS ) {
        int index;

        index = *EventCode;

    if ( (index+1) < num_events ) {
       *EventCode = *EventCode + 1;
       return PAPI_OK;
    } else {
       return PAPI_ENOEVNT;
    }
     } 
        
     return PAPI_EINVAL;
}

_stealtime_read()

static int _stealtime_read ( hwd_context_t *  ctx, hwd_control_state_t *  ctl, long long **  events, int  flags  )

static

Definition at line 382 of file linux-stealtime.c.

{
    ( void ) flags;

    struct STEALTIME_control_state *control;
    struct STEALTIME_context *context;

    int i;
    
    control = (struct STEALTIME_control_state *)ctl;
    context = (struct STEALTIME_context *)ctx;

    read_stealtime( context, 0 );

    for(i=0;i<control->num_events;i++) {
       control->values[i]=
                 context->value[control->which_counter[i]];
    }

    *events = control->values;

    return PAPI_OK;

}

Here is the call graph for this function:

_stealtime_reset()

static int _stealtime_reset ( hwd_context_t *  ctx, hwd_control_state_t *  ctrl  )

static

Definition at line 415 of file linux-stealtime.c.

{

  /* re-initializes counter_start values to current */

  _stealtime_start(ctx,ctrl);

  return PAPI_OK;
}

Here is the call graph for this function:

_stealtime_set_domain()

static int _stealtime_set_domain ( hwd_control_state_t *  cntrl, int  domain  )

static

Definition at line 470 of file linux-stealtime.c.

{
    ( void ) cntrl;
    int found = 0;
    if ( PAPI_DOM_USER & domain ) {
        found = 1;
    }
    if ( PAPI_DOM_KERNEL & domain ) {
        found = 1;
    }
    if ( PAPI_DOM_OTHER & domain ) {
        found = 1;
    }
    if ( !found )
        return PAPI_EINVAL;

    return PAPI_OK;
}

_stealtime_shutdown_component()

static int _stealtime_shutdown_component ( void  )

static

Definition at line 239 of file linux-stealtime.c.

{
       int i;
       int num_events = _stealtime_vector.cmp_info.num_native_events;
       if (event_info!=NULL) {
               for (i=0; i<num_events; i++){
                       free(event_info[i].name);
                       free(event_info[i].description);
                       free(event_info[i].units);
               }
               free(event_info);
       }

   return PAPI_OK;
}

Here is the caller graph for this function:

_stealtime_shutdown_thread()

static int _stealtime_shutdown_thread ( hwd_context_t *  ctx )

static

Definition at line 259 of file linux-stealtime.c.

{

  struct STEALTIME_context *context=(struct STEALTIME_context *)ctx;

  if (context->start_count!=NULL) free(context->start_count);
  if (context->current_count!=NULL) free(context->current_count);
  if (context->value!=NULL) free(context->value);

  return PAPI_OK;
}

_stealtime_start()

static int _stealtime_start ( hwd_context_t *  ctx, hwd_control_state_t *  ctl  )

static

Definition at line 334 of file linux-stealtime.c.

{

  (void)ctl;

  //    struct STEALTIME_control_state *control;
    struct STEALTIME_context *context;
    
    //control = (struct STEALTIME_control_state *)ctl;
    context = (struct STEALTIME_context *)ctx;

    read_stealtime( context, 1 );

    /* no need to update control, as we assume only one EventSet  */
    /* is active at once, so starting things at the context level */
    /* is fine, since stealtime is system-wide                    */

    return PAPI_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

_stealtime_stop()

static int _stealtime_stop ( hwd_context_t *  ctx, hwd_control_state_t *  ctl  )

static

Definition at line 359 of file linux-stealtime.c.

{

  (void) ctl;

  //    struct STEALTIME_control_state *control;
    struct STEALTIME_context *context;
    
    //control = (struct STEALTIME_control_state *)ctl;
    context = (struct STEALTIME_context *)ctx;

    read_stealtime( context, 0 );

    return PAPI_OK;

}

Here is the call graph for this function:

_stealtime_update_control_state()

static int _stealtime_update_control_state ( hwd_control_state_t *  ctl, NativeInfo_t *  native, int  count, hwd_context_t *  ctx  )

static

Definition at line 295 of file linux-stealtime.c.

{

    struct STEALTIME_control_state *control;

    ( void ) ctx;
    int i, index;

    control= (struct STEALTIME_control_state *)ctl;

    if (count!=control->num_events) {
      //       printf("Resizing %d to %d\n",control->num_events,count);
       control->which_counter=realloc(control->which_counter,
                      count*sizeof(int));
       control->values=realloc(control->values,
                   count*sizeof(long long));
       
    }


    for ( i = 0; i < count; i++ ) {
       index = native[i].ni_event;
       control->which_counter[i]=index;
       native[i].ni_position = i;
    }

    control->num_events=count;

    return PAPI_OK;
}

read_stealtime()

static int read_stealtime ( struct STEALTIME_context *  context, int  starting  )

static

Definition at line 74 of file linux-stealtime.c.

                                                                 {

  FILE *fff;
  char buffer[BUFSIZ],*result;
  int i,count;
  struct statinfo our_stat;

  int hz=sysconf(_SC_CLK_TCK);


  fff=fopen("/proc/stat","r");
  if (fff==NULL) {
     return PAPI_ESYS; 
  }

  for(i=0;i<num_events;i++) {
    result=fgets(buffer,BUFSIZ,fff);
    if (result==NULL) break;

    count=sscanf(buffer,"%*s %lld %lld %lld %lld %lld %lld %lld %lld %lld",
         &our_stat.user,
         &our_stat.nice,
         &our_stat.system,
         &our_stat.idle,
         &our_stat.iowait,
         &our_stat.irq,
         &our_stat.softirq,
         &our_stat.steal,
         &our_stat.guest);
    if (count<=7) {
       fclose(fff);
       return PAPI_ESYS;
    }

    if (starting) {
       context->start_count[i]=our_stat.steal;
    }
    context->current_count[i]=our_stat.steal;

    /* convert to us */
    context->value[i]=(context->current_count[i]-context->start_count[i])*
      (1000000/hz);
  }
  

  fclose(fff);

  return PAPI_OK;

}

Here is the caller graph for this function:

Variable Documentation

_stealtime_vector

papi_vector_t _stealtime_vector

Definition at line 55 of file linux-stealtime.c.

event_info

struct counter_info* event_info =NULL

static

Definition at line 52 of file linux-stealtime.c.

num_events

int num_events = 0

static

Definition at line 50 of file linux-stealtime.c.