linux-io.c File Reference

io component This component provides access to the I/O statistics in the system file /proc/self/io. It typically contains 7 counters, but for robusness we read the file and create whatever events it contains. More...

Include dependency graph for linux-io.c:

Go to the source code of this file.

Data Structures
struct	IO_native_event_entry_t
struct	_io_control_state_t
struct	_io_context_t

Macros
#define	FILE_LINE_SIZE   256
#define	IO_COUNTERS   64
#define	IO_FILENAME   "/proc/self/io"
#define	HANDLE_STRING_ERROR   {fprintf(stderr,"%s:%i unexpected string function error.\n",__FILE__,__LINE__); exit(-1);}

Functions
static int	io_count_events (_io_context_t *myCtx)
static int	io_hardware_read (_io_context_t *ctx, _io_control_state_t *ctl)
static int	_io_init_component (int cidx)
static int	_io_init_thread (hwd_context_t *ctx)
static int	_io_init_control_state (hwd_control_state_t *ctl)
static int	_io_update_control_state (hwd_control_state_t *ctl, NativeInfo_t *native, int count, hwd_context_t *ctx)
static int	_io_start (hwd_context_t *ctx, hwd_control_state_t *ctl)
static int	_io_stop (hwd_context_t *ctx, hwd_control_state_t *ctl)
static int	_io_read (hwd_context_t *ctx, hwd_control_state_t *ctl, long long **events, int flags)
static int	_io_write (hwd_context_t *ctx, hwd_control_state_t *ctl, long long *events)
static int	_io_reset (hwd_context_t *ctx, hwd_control_state_t *ctl)
static int	_io_shutdown_component (void)
static int	_io_shutdown_thread (hwd_context_t *ctx)
static int	_io_ctl (hwd_context_t *ctx, int code, _papi_int_option_t *option)
static int	_io_set_domain (hwd_control_state_t *cntrl, int domain)
static int	_io_ntv_enum_events (unsigned int *EventCode, int modifier)
static int	_io_ntv_code_to_name (unsigned int EventCode, char *name, int len)
static int	_io_ntv_code_to_descr (unsigned int EventCode, char *descr, int len)

Variables
papi_vector_t	_io_vector
static int	gEventCount
static IO_native_event_entry_t *	io_native_table

Detailed Description

Author

Kevin A. Huck khuck.nosp@m.@uor.nosp@m.egon..nosp@m.edu

Definition in file linux-io.c.

Macro Definition Documentation

FILE_LINE_SIZE

#define FILE_LINE_SIZE   256

Definition at line 31 of file linux-io.c.

HANDLE_STRING_ERROR

#define HANDLE_STRING_ERROR   {fprintf(stderr,"%s:%i unexpected string function error.\n",__FILE__,__LINE__); exit(-1);}

Definition at line 41 of file linux-io.c.

IO_COUNTERS

#define IO_COUNTERS   64

Definition at line 34 of file linux-io.c.

IO_FILENAME

#define IO_FILENAME   "/proc/self/io"

Definition at line 36 of file linux-io.c.

Function Documentation

_io_ctl()

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

static

This function sets various options in the component

Parameters

[in]	ctx	– hardware context
[in]	code	valid are PAPI_SET_DEFDOM, PAPI_SET_DOMAIN, PAPI_SETDEFGRN, PAPI_SET_GRANUL and PAPI_SET_INHERIT
[in]	option	– options to be set

Definition at line 431 of file linux-io.c.

{
    (void) ctx;
    (void) code;
    (void) option;
    SUBDBG( "io_ctl..." );
    return PAPI_OK;
}

_io_init_component()

static int _io_init_component ( int  cidx )

static

Initialize hardware counters, setup the function vector table and get hardware information, this routine is called when the PAPI process is initialized (IE PAPI_library_init)

Definition at line 170 of file linux-io.c.

{
    _io_context_t myCtx;
    int ret, fileIdx;
    SUBDBG( "_io_init_component..." );
   
    ret = io_count_events(&myCtx);
    if (ret != PAPI_OK) {
        int strErr=snprintf(_io_vector.cmp_info.disabled_reason, PAPI_MAX_STR_LEN,
        "Failed counting events.");
        _io_vector.cmp_info.disabled_reason[PAPI_MAX_STR_LEN-1]=0;    // force null termination.
        if (strErr > PAPI_MAX_STR_LEN) HANDLE_STRING_ERROR;
        goto fn_fail;
    }
 
    rewind(myCtx.pFile);
 
    if (myCtx.EventCount > IO_COUNTERS) {
        int strErr=snprintf(_io_vector.cmp_info.disabled_reason, PAPI_MAX_STR_LEN,
        "File '%s' has %i events, exceeds counter limit of %i.", IO_FILENAME, myCtx.EventCount, IO_COUNTERS);
        _io_vector.cmp_info.disabled_reason[PAPI_MAX_STR_LEN-1]=0;
        if (strErr > PAPI_MAX_STR_LEN) HANDLE_STRING_ERROR;
        fclose(myCtx.pFile);
        ret = PAPI_ENOSUPP;
        goto fn_fail;
    }
 
    // Must be same for all threads, now.
    gEventCount = myCtx.EventCount;
    /* Allocate memory for the native event table */
    io_native_table =
        ( IO_native_event_entry_t * )
        papi_calloc(gEventCount, sizeof(IO_native_event_entry_t) );
    if ( io_native_table == NULL ) {
        int strErr=snprintf(_io_vector.cmp_info.disabled_reason, PAPI_MAX_STR_LEN,
        "Failed to allocate %lu bytes for _io_native_table.", gEventCount*sizeof(IO_native_event_entry_t));
        _io_vector.cmp_info.disabled_reason[PAPI_MAX_STR_LEN-1]=0;
        if (strErr > PAPI_MAX_STR_LEN) HANDLE_STRING_ERROR;
        fclose(myCtx.pFile);
        ret = PAPI_ENOMEM;
        goto fn_fail;
    }
 
    for (fileIdx = 0; fileIdx < gEventCount; fileIdx++) {
        (void) fgets(myCtx.line, FILE_LINE_SIZE, myCtx.pFile);
        char name[FILE_LINE_SIZE] = {0};
        long long tmplong = 0LL;
        // No check for error here, we would have caught it in io_count_events().
        (void) sscanf(myCtx.line, "%s %lld\n", name, &tmplong);
        name[strlen(name)-1]=0;     // null terminate over ':' we found.
        strncpy(io_native_table[fileIdx].name, name, PAPI_MAX_STR_LEN-1);
        io_native_table[fileIdx].fileIdx=fileIdx;
        io_native_table[fileIdx].desc[0]=0;         // flag for successful copy.
        if (strcmp("rchar", name) == 0) {
            strcpy(io_native_table[fileIdx].desc, "Characters read.");
        }
        if (strcmp("wchar", name) == 0) {
            strcpy(io_native_table[fileIdx].desc, "Characters written."); 
        }
        if (strcmp("syscr", name) == 0) {
            strcpy(io_native_table[fileIdx].desc, "Characters read by system calls."); 
        }
        if (strcmp("syscw", name) == 0) {
            strcpy(io_native_table[fileIdx].desc, "Characters written by system calls."); 
        }
        if (strcmp("read_bytes", name) == 0) {
            strcpy(io_native_table[fileIdx].desc, "Binary bytes read."); 
        }
        if (strcmp("write_bytes", name) == 0) {
            strcpy(io_native_table[fileIdx].desc, "Binary bytes written."); 
        }
        if (strcmp("cancelled_write_bytes", name) == 0) {
            strcpy(io_native_table[fileIdx].desc, "Binary write bytes cancelled."); 
        }
                     
        // If none of the above found, generic description.
        if (io_native_table[fileIdx].desc[0] == 0) {    
            strcpy(io_native_table[fileIdx].desc, "No description available."); 
        }
    } // END READING.
 
    fclose(myCtx.pFile);
    // Export the total number of events available, at least on the init thread.
    _io_vector.cmp_info.num_native_events = gEventCount;
    _io_vector.cmp_info.num_cntrs = IO_COUNTERS;
    _io_vector.cmp_info.num_mpx_cntrs = IO_COUNTERS;
 
    /* Export the component id */
    _io_vector.cmp_info.CmpIdx = cidx;
  fn_exit:
    _papi_hwd[cidx]->cmp_info.disabled = ret;
    return ret;
  fn_fail:
    goto fn_exit;
} // END ROUTINE.

Here is the call graph for this function:

_io_init_control_state()

static int _io_init_control_state ( hwd_control_state_t *  ctl )

static

Definition at line 292 of file linux-io.c.

{
    _io_control_state_t* control = ( _io_control_state_t* ) ctl;
    memset(control, 0, sizeof(_io_control_state_t));
    return PAPI_OK;
} // END.

_io_init_thread()

static int _io_init_thread ( hwd_context_t *  ctx )

static

Definition at line 271 of file linux-io.c.

{
    _io_context_t* myCtx = (_io_context_t*) ctx;
    int ret;
    ret = io_count_events(myCtx);
    if (ret != PAPI_OK) return(ret);
 
    // File mismatch on event count kills it.
    if (gEventCount > 0 && myCtx->EventCount != gEventCount) {
        fclose(myCtx->pFile);
        myCtx->pFile = NULL;
        return PAPI_ENOSUPP;
    }
 
    fclose(myCtx->pFile);
    return PAPI_OK;
} // END of init thread.

Here is the call graph for this function:

_io_ntv_code_to_descr()

static int _io_ntv_code_to_descr ( unsigned int  EventCode, char *  descr, int  len  )

static

Takes a native event code and passes back the event description

Parameters

EventCode	is the native event code
descr	is a pointer for the description to be copied to
len	is the size of the descr string

Definition at line 549 of file linux-io.c.

{
    int index;
    index = EventCode;
 
    /* make sure event is in range */
    if (index >= 0 && index < gEventCount) {
        strncpy( descr, io_native_table[index].desc, len );
        return PAPI_OK;
    }
 
    return PAPI_ENOEVNT;
}

_io_ntv_code_to_name()

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

static

Takes a native event code and passes back the name

Parameters

EventCode	is the native event code
name	is a pointer for the name to be copied to
len	is the size of the name string

Definition at line 529 of file linux-io.c.

{
    int index;
    index = EventCode;
 
    /* Make sure we are in range */
    if (index >= 0 && index < gEventCount) {
        strncpy(name, io_native_table[index].name, len );  
        return PAPI_OK;
    }
 
    return PAPI_ENOEVNT;
} // END ROUTINE.

_io_ntv_enum_events()

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

static

Enumerate Native Events

Parameters

EventCode	is the event of interest
modifier	is one of PAPI_ENUM_FIRST, PAPI_ENUM_EVENTS If your component has attribute masks then these need to be handled here as well.

Definition at line 492 of file linux-io.c.

{
    int index;
 
    switch ( modifier ) {
 
        /* return EventCode of first event */
        case PAPI_ENUM_FIRST:
            *EventCode = 0;
            return PAPI_OK;
 
        /* return EventCode of next available event */
        case PAPI_ENUM_EVENTS:
            index = *EventCode;
 
            /* Make sure we have at least 1 more event after us */
            if ( index < (gEventCount-1) ) {
                *EventCode = *EventCode + 1;
                return PAPI_OK;
            } else {
                return PAPI_ENOEVNT;
            }
            break;
 
        default:
            return PAPI_EINVAL;
    }
 
    return PAPI_EINVAL;
} // END ROUTINE

_io_read()

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

static

Definition at line 358 of file linux-io.c.

{
    // Prevent 'unused' warnings from compiler.
    (void) flags;
    _io_context_t *myCtx = (_io_context_t*) ctx;
    _io_control_state_t *myCtl = (_io_control_state_t*) ctl;
    int i;
    SUBDBG( "io_read... %p %d", ctx, flags );
 
    /* Read all counters into EventSetVal */
    io_hardware_read(myCtx, myCtl);
    for (i=0; i<myCtl->EventSetCount; i++) {
        myCtl->EventSetReport[i]=myCtl->EventSetVal[myCtl->EventSetIdx[i]];
    }
 
    /* return pointer to the values we read */
    *events = myCtl->EventSetReport; 
 
    return PAPI_OK;
}

Here is the call graph for this function:

_io_reset()

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

static

Triggered by PAPI_reset() but only if the EventSet is currently running

Definition at line 399 of file linux-io.c.

{
    (void) ctx; // unused
    (void) ctl;
    SUBDBG( "io_reset...");
    return PAPI_OK;
}

_io_set_domain()

static int _io_set_domain ( hwd_control_state_t *  cntrl, int  domain  )

static

This function has to set the bits needed to count different domains In particular: PAPI_DOM_USER, PAPI_DOM_KERNEL PAPI_DOM_OTHER By default return PAPI_EINVAL if none of those are specified and PAPI_OK with success PAPI_DOM_USER is only user context is counted PAPI_DOM_KERNEL is only the Kernel/OS context is counted PAPI_DOM_OTHER is Exception/transient mode (like user TLB misses) PAPI_DOM_ALL is all of the domains

Definition at line 450 of file linux-io.c.

{
    (void) cntrl;
 
    int found = 0;
    SUBDBG( "io_set_domain..." );
 
    if ( PAPI_DOM_USER & domain ) {
        SUBDBG( " PAPI_DOM_USER " );
        found = 1;
    }
    if ( PAPI_DOM_KERNEL & domain ) {
        SUBDBG( " PAPI_DOM_KERNEL " );
        found = 1;
    }
    if ( PAPI_DOM_OTHER & domain ) {
        SUBDBG( " PAPI_DOM_OTHER " );
        found = 1;
    }
    if ( PAPI_DOM_ALL & domain ) {
        SUBDBG( " PAPI_DOM_ALL " );
        found = 1;
    }
    if ( !found )
        return ( PAPI_EINVAL );
 
    return PAPI_OK;
}

_io_shutdown_component()

static int _io_shutdown_component ( void  )

static

Definition at line 409 of file linux-io.c.

{
    SUBDBG( "io_shutdown_component..." );
    return PAPI_OK;
}

_io_shutdown_thread()

static int _io_shutdown_thread ( hwd_context_t *  ctx )

static

Definition at line 417 of file linux-io.c.

{
    (void) ctx;
    SUBDBG( "io_shutdown_thread... %p", ctx );
    return PAPI_OK;
}

_io_start()

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

static

Triggered by PAPI_start()

Definition at line 332 of file linux-io.c.

{
    (void) ctl;
    (void) ctx;
    SUBDBG( "io_start %p %p...", ctx, ctl );
    return PAPI_OK;
}

_io_stop()

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

static

Triggered by PAPI_stop()

Definition at line 343 of file linux-io.c.

{
    (void) ctx;
    (void) ctl;
    SUBDBG( "io_stop %p %p...", ctx, ctl );
    // Don't do anything, can't stop the counters.
 
    return PAPI_OK;
}

_io_update_control_state()

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

static

Definition at line 303 of file linux-io.c.

{
    (void) ctx;
    _io_control_state_t *myCtl = (_io_control_state_t*) ctl;
    
    int i, index;
 
    myCtl->EventSetCount = count;
    
    /* if no events, return */
    if (count==0) return PAPI_OK;
 
    for( i = 0; i < count; i++ ) {
        index = native[i].ni_event;
        myCtl->EventSetIdx[i] = index;    
 
        /* We have no constraints on event position, so any event */
        /* can be in any slot.                                    */
        native[i].ni_position = i;
    }
 
    return PAPI_OK;
} // END ROUTINE.

_io_write()

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

static

Triggered by PAPI_write(), but only if the counters are running

Definition at line 383 of file linux-io.c.

{
    (void) ctx;    // unused
    (void) ctl;    // unused
    (void) events; // unused
 
    return PAPI_OK;
}

io_count_events()

static int io_count_events ( _io_context_t *  myCtx )

static

Definition at line 82 of file linux-io.c.

{
    myCtx->EventCount = 0;
    myCtx->pFile = fopen (IO_FILENAME,"r");
    if (myCtx->pFile == NULL) {
        int strErr=snprintf(_io_vector.cmp_info.disabled_reason, PAPI_MAX_STR_LEN,
        "Failed to open target file '%s'.", IO_FILENAME);
        _io_vector.cmp_info.disabled_reason[PAPI_MAX_STR_LEN-1]=0;
        if (strErr > PAPI_MAX_STR_LEN) HANDLE_STRING_ERROR;
        return PAPI_ENOSUPP;
    }
 
    // Just count the lines, basic vetting for ability to parse.
    while (1) {
        char *res;
        // fgets guarantees z-terminator, reads at most FILE_LINE_SIZE-1 bytes.
        res = fgets(myCtx->line, FILE_LINE_SIZE, myCtx->pFile);
        if (res  == NULL) break;
        // If the read filled the whole buffer, line is too long.
        if (strlen(myCtx->line) == (FILE_LINE_SIZE-1)) {
            fclose(myCtx->pFile);
            int strErr=snprintf(_io_vector.cmp_info.disabled_reason, PAPI_MAX_STR_LEN,
            "File '%s' line %i too long.", IO_FILENAME, myCtx->EventCount+1);
            _io_vector.cmp_info.disabled_reason[PAPI_MAX_STR_LEN-1]=0;
            if (strErr > PAPI_MAX_STR_LEN) HANDLE_STRING_ERROR;
            return PAPI_ENOSUPP;
        }
 
        char dummy[FILE_LINE_SIZE] = {0};
        long long tmplong = 0LL;
        int nf = sscanf( myCtx->line, "%s %lld\n", dummy, &tmplong);
        if (nf != 2 || strlen(dummy)<2 || dummy[strlen(dummy)-1] != ':') {
            fclose(myCtx->pFile);
            int strErr=snprintf(_io_vector.cmp_info.disabled_reason, PAPI_MAX_STR_LEN,
            "File '%s' line %i bad format.", IO_FILENAME, myCtx->EventCount+1);
            _io_vector.cmp_info.disabled_reason[PAPI_MAX_STR_LEN-1]=0;
            if (strErr > PAPI_MAX_STR_LEN) HANDLE_STRING_ERROR;
            return PAPI_ENOSUPP;
        }
 
        myCtx->EventCount++; 
    } // END READING.
 
    // NOTE: We intentionally leave file open; up to caller to close
    // or rewind and continue.
    return PAPI_OK;
} // END ROUTINE.

Here is the call graph for this function:

Here is the caller graph for this function:

io_hardware_read()

static int io_hardware_read ( _io_context_t *  ctx, _io_control_state_t *  ctl  )

static

Definition at line 135 of file linux-io.c.

{
    ctx->pFile = fopen(IO_FILENAME, "r");
    if (ctx->pFile == NULL) return(PAPI_ENOCNTR); /* No counters */
 
    /* Read each line */
    int idx;
    for (idx=0; idx<gEventCount; idx++) {
        if (fgets(ctx->line, FILE_LINE_SIZE-1, ctx->pFile)) {
            char dummy[FILE_LINE_SIZE] = {0};
            long long tmplong = 0LL;
            int nf = sscanf(ctx->line, "%s %lld\n", dummy, &tmplong);
            if (nf != 2 || strlen(dummy)<2 || dummy[strlen(dummy)-1] != ':') {
                return PAPI_ENOCNTR;
            }
 
            ctl->EventSetVal[idx] = tmplong;
        } else {                            /* Did not read ALL counters. */
            return(PAPI_EMISC);
        }
    }
 
    fclose(ctx->pFile);
    return(PAPI_OK);
} // END FUNCTION.

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

_io_vector

papi_vector_t _io_vector

Vector that points to entry points for our component

Definition at line 28 of file linux-io.c.

gEventCount

int gEventCount

static

Definition at line 77 of file linux-io.c.

io_native_table

IO_native_event_entry_t* io_native_table

static

Definition at line 78 of file linux-io.c.