appio.c File Reference

appio component This file contains the source code for a component that enables PAPI to access application level file and socket I/O information. It does this through function replacement in the first person and by trapping syscalls in the third person. More...

Include dependency graph for appio.c:

Go to the source code of this file.

Data Structures
struct	appio_counters

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

Enumerations
enum	_appio_stats_t {   READ_BYTES = 0 , READ_CALLS , READ_ERR , READ_INTERRUPTED ,   READ_WOULD_BLOCK , READ_SHORT , READ_EOF , READ_BLOCK_SIZE ,   READ_USEC , WRITE_BYTES , WRITE_CALLS , WRITE_ERR ,   WRITE_SHORT , WRITE_INTERRUPTED , WRITE_WOULD_BLOCK , WRITE_BLOCK_SIZE ,   WRITE_USEC , OPEN_CALLS , OPEN_ERR , OPEN_FDS ,   SELECT_USEC , RECV_BYTES , RECV_CALLS , RECV_ERR ,   RECV_INTERRUPTED , RECV_WOULD_BLOCK , RECV_SHORT , RECV_EOF ,   RECV_BLOCK_SIZE , RECV_USEC , SOCK_READ_BYTES , SOCK_READ_CALLS ,   SOCK_READ_ERR , SOCK_READ_SHORT , SOCK_READ_WOULD_BLOCK , SOCK_READ_USEC ,   SOCK_WRITE_BYTES , SOCK_WRITE_CALLS , SOCK_WRITE_ERR , SOCK_WRITE_SHORT ,   SOCK_WRITE_WOULD_BLOCK , SOCK_WRITE_USEC , SEEK_CALLS , SEEK_ABS_STRIDE_SIZE ,   SEEK_USEC }

Functions
int	__close (int fd)
int	close (int fd)
int	__open (const char *pathname, int flags, mode_t mode)
int	open (const char *pathname, int flags, mode_t mode)
int	__select (int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout)
int	select (int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout)
off_t	__lseek (int fd, off_t offset, int whence)
off_t	lseek (int fd, off_t offset, int whence)
ssize_t	__read (int fd, void *buf, size_t count)
ssize_t	read (int fd, void *buf, size_t count)
size_t	_IO_fread (void *ptr, size_t size, size_t nmemb, FILE *stream)
size_t	fread (void *ptr, size_t size, size_t nmemb, FILE *stream)
ssize_t	__write (int fd, const void *buf, size_t count)
ssize_t	write (int fd, const void *buf, size_t count)
size_t	_IO_fwrite (const void *ptr, size_t size, size_t nmemb, FILE *stream)
size_t	fwrite (const void *ptr, size_t size, size_t nmemb, FILE *stream)
static int	_appio_init_thread (hwd_context_t *ctx)
static int	_appio_init_component (int cidx)
static int	_appio_init_control_state (hwd_control_state_t *ctl)
static int	_appio_start (hwd_context_t *ctx, hwd_control_state_t *ctl)
static int	_appio_read (hwd_context_t *ctx, hwd_control_state_t *ctl, long long **events, int flags)
static int	_appio_stop (hwd_context_t *ctx, hwd_control_state_t *ctl)
static int	_appio_shutdown_thread (hwd_context_t *ctx)
static int	_appio_shutdown_component (void)
static int	_appio_ctl (hwd_context_t *ctx, int code, _papi_int_option_t *option)
static int	_appio_update_control_state (hwd_control_state_t *ctl, NativeInfo_t *native, int count, hwd_context_t *ctx)
static int	_appio_set_domain (hwd_control_state_t *ctl, int domain)
static int	_appio_reset (hwd_context_t *ctx, hwd_control_state_t *ctl)
static int	_appio_ntv_enum_events (unsigned int *EventCode, int modifier)
static int	_appio_ntv_name_to_code (const char *name, unsigned int *EventCode)
static int	_appio_ntv_code_to_name (unsigned int EventCode, char *name, int len)
static int	_appio_ntv_code_to_descr (unsigned int EventCode, char *desc, int len)
static int	_appio_ntv_code_to_bits (unsigned int EventCode, hwd_register_t *bits)

Variables
papi_vector_t	_appio_vector
static APPIO_native_event_entry_t *	_appio_native_events
static __thread long long	_appio_register_current [APPIO_MAX_COUNTERS]
static const struct appio_counters	_appio_counter_info [APPIO_MAX_COUNTERS]
struct timeval	zerotv
int	errno

Detailed Description

Author

Philip Mucci phil..nosp@m.mucc.nosp@m.i@sam.nosp@m.arat.nosp@m.echno.nosp@m.logy.nosp@m.group.nosp@m..com

Tushar Mohan tusha.nosp@m.rmoh.nosp@m.an@gm.nosp@m.ail..nosp@m.com

Credit to: Jose Pedro Oliveira jpo@d.nosp@m.i.um.nosp@m.inho..nosp@m.pt whose code in the linux net component was used as a template for many sections of code in this component.

Definition in file appio.c.

Macro Definition Documentation

HANDLE_STRING_ERROR

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

Definition at line 172 of file appio.c.

Enumeration Type Documentation

_appio_stats_t

enum _appio_stats_t

Enumerator
READ_BYTES
READ_CALLS
READ_ERR
READ_INTERRUPTED
READ_WOULD_BLOCK
READ_SHORT
READ_EOF
READ_BLOCK_SIZE
READ_USEC
WRITE_BYTES
WRITE_CALLS
WRITE_ERR
WRITE_SHORT
WRITE_INTERRUPTED
WRITE_WOULD_BLOCK
WRITE_BLOCK_SIZE
WRITE_USEC
OPEN_CALLS
OPEN_ERR
OPEN_FDS
SELECT_USEC
RECV_BYTES
RECV_CALLS
RECV_ERR
RECV_INTERRUPTED
RECV_WOULD_BLOCK
RECV_SHORT
RECV_EOF
RECV_BLOCK_SIZE
RECV_USEC
SOCK_READ_BYTES
SOCK_READ_CALLS
SOCK_READ_ERR
SOCK_READ_SHORT
SOCK_READ_WOULD_BLOCK
SOCK_READ_USEC
SOCK_WRITE_BYTES
SOCK_WRITE_CALLS
SOCK_WRITE_ERR
SOCK_WRITE_SHORT
SOCK_WRITE_WOULD_BLOCK
SOCK_WRITE_USEC
SEEK_CALLS
SEEK_ABS_STRIDE_SIZE
SEEK_USEC

Definition at line 70 of file appio.c.

             {
  READ_BYTES = 0,
  READ_CALLS,
  READ_ERR,
  READ_INTERRUPTED,
  READ_WOULD_BLOCK,
  READ_SHORT,
  READ_EOF,
  READ_BLOCK_SIZE,
  READ_USEC,
  WRITE_BYTES,
  WRITE_CALLS,
  WRITE_ERR,
  WRITE_SHORT,
  WRITE_INTERRUPTED,
  WRITE_WOULD_BLOCK,
  WRITE_BLOCK_SIZE,
  WRITE_USEC,
  OPEN_CALLS,
  OPEN_ERR,
  OPEN_FDS,
  SELECT_USEC,
  RECV_BYTES,
  RECV_CALLS,
  RECV_ERR,
  RECV_INTERRUPTED,
  RECV_WOULD_BLOCK,
  RECV_SHORT,
  RECV_EOF,
  RECV_BLOCK_SIZE,
  RECV_USEC,
  SOCK_READ_BYTES,
  SOCK_READ_CALLS,
  SOCK_READ_ERR,
  SOCK_READ_SHORT,
  SOCK_READ_WOULD_BLOCK,
  SOCK_READ_USEC,
  SOCK_WRITE_BYTES,
  SOCK_WRITE_CALLS,
  SOCK_WRITE_ERR,
  SOCK_WRITE_SHORT,
  SOCK_WRITE_WOULD_BLOCK,
  SOCK_WRITE_USEC,
  SEEK_CALLS,
  SEEK_ABS_STRIDE_SIZE,
  SEEK_USEC
} _appio_stats_t ;

Function Documentation

__close()

int __close

(

int

fd

)

Here is the caller graph for this function:

__lseek()

off_t __lseek	(	int	fd,
		off_t	offset,
		int	whence
	)

Here is the caller graph for this function:

__open()

int __open	(	const char *	pathname,
		int	flags,
		mode_t	mode
	)

Here is the caller graph for this function:

__read()

ssize_t __read	(	int	fd,
		void *	buf,
		size_t	count
	)

Here is the caller graph for this function:

__select()

int __select	(	int	nfds,
		fd_set *	readfds,
		fd_set *	writefds,
		fd_set *	exceptfds,
		struct timeval *	timeout
	)

Here is the caller graph for this function:

__write()

ssize_t __write	(	int	fd,
		const void *	buf,
		size_t	count
	)

Here is the caller graph for this function:

_appio_ctl()

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

static

Definition at line 567 of file appio.c.

{
    ( void ) ctx;
    ( void ) code;
    ( void ) option;
 
    return PAPI_OK;
}

_appio_init_component()

static int _appio_init_component ( int  cidx )

static

Definition at line 431 of file appio.c.

{
    int strErr;
    int retval = PAPI_OK;
    SUBDBG("_appio_component %d\n", cidx);
    _appio_native_events = (APPIO_native_event_entry_t *) papi_calloc(APPIO_MAX_COUNTERS, sizeof(APPIO_native_event_entry_t));
 
    if (_appio_native_events == NULL ) {
      PAPIERROR( "malloc():Could not get memory for events table" );
      strErr=snprintf(_appio_vector.cmp_info.disabled_reason, PAPI_MAX_STR_LEN, "malloc() failed in %s for %lu bytes.", __func__, APPIO_MAX_COUNTERS*sizeof(APPIO_native_event_entry_t));
      _appio_vector.cmp_info.disabled_reason[PAPI_MAX_STR_LEN-1]=0;
      if (strErr>PAPI_MAX_STR_LEN) HANDLE_STRING_ERROR;
      retval = PAPI_ENOMEM;
      goto fn_fail;
    }
    int i;
    for (i=0; i<APPIO_MAX_COUNTERS; i++) {
      _appio_native_events[i].name = _appio_counter_info[i].name;
      _appio_native_events[i].description = _appio_counter_info[i].description;
      _appio_native_events[i].resources.selector = i + 1;
    }
  
    /* Export the total number of events available */
    _appio_vector.cmp_info.num_native_events = APPIO_MAX_COUNTERS;;
 
    /* Export the component id */
    _appio_vector.cmp_info.CmpIdx = cidx;
 
  fn_exit:
    _papi_hwd[cidx]->cmp_info.disabled = retval;
    return retval;
  fn_fail:
    goto fn_exit;
}

Here is the call graph for this function:

_appio_init_control_state()

static int _appio_init_control_state ( hwd_control_state_t *  ctl )

static

Definition at line 472 of file appio.c.

{
    ( void ) ctl;
 
    return PAPI_OK;
}

_appio_init_thread()

static int _appio_init_thread ( hwd_context_t *  ctx )

static

Definition at line 417 of file appio.c.

{
    ( void ) ctx;
    SUBDBG("_appio_init_thread %p\n", ctx);
    return PAPI_OK;
}

_appio_ntv_code_to_bits()

static int _appio_ntv_code_to_bits ( unsigned int  EventCode, hwd_register_t *  bits  )

static

Definition at line 725 of file appio.c.

{
    int index = EventCode;
 
    if ( index >= 0 && index < APPIO_MAX_COUNTERS ) {
        memcpy( ( APPIO_register_t * ) bits,
                &( _appio_native_events[index].resources ),
                sizeof ( APPIO_register_t ) );
        return PAPI_OK;
    }
 
    return PAPI_ENOEVNT;
}

_appio_ntv_code_to_descr()

static int _appio_ntv_code_to_descr ( unsigned int  EventCode, char *  desc, int  len  )

static

Definition at line 708 of file appio.c.

{
    int index = EventCode;
 
    if ( index >= 0 && index < APPIO_MAX_COUNTERS ) {
        strncpy(desc, _appio_counter_info[index].description, len );
        return PAPI_OK;
    }
 
    return PAPI_ENOEVNT;
}

_appio_ntv_code_to_name()

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

static

Definition at line 691 of file appio.c.

{
    int index = EventCode;
 
    if ( index >= 0 && index < APPIO_MAX_COUNTERS ) {
        strncpy( name, _appio_counter_info[index].name, len );
        return PAPI_OK;
    }
 
    return PAPI_ENOEVNT;
}

_appio_ntv_enum_events()

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

static

Definition at line 640 of file appio.c.

{
    int index;
 
    switch ( modifier ) {
        case PAPI_ENUM_FIRST:
            *EventCode = 0;
            return PAPI_OK;
            break;
 
        case PAPI_ENUM_EVENTS:
            index = *EventCode;
            if ( index < APPIO_MAX_COUNTERS - 1 ) {
                *EventCode = *EventCode + 1;
                return PAPI_OK;
            } else {
                return PAPI_ENOEVNT;
            }
            break;
 
        default:
            return PAPI_EINVAL;
            break;
    }
    return PAPI_EINVAL;
}

_appio_ntv_name_to_code()

static int _appio_ntv_name_to_code ( const char *  name, unsigned int *  EventCode  )

static

Definition at line 672 of file appio.c.

{
    int i;
 
    for ( i=0; i<APPIO_MAX_COUNTERS; i++) {
        if (strcmp(name, _appio_counter_info[i].name) == 0) {
            *EventCode = i;
            return PAPI_OK;
        }
    }
 
    return PAPI_ENOEVNT;
}

_appio_read()

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

static

Definition at line 499 of file appio.c.

{
    (void) flags;
    (void) ctx;
 
    SUBDBG("_appio_read %p %p\n", ctx, ctl);
    APPIO_control_state_t *appio_ctl = (APPIO_control_state_t *) ctl;
    int i;
 
    for ( i=0; i<appio_ctl->num_events; i++ ) {
            int index = appio_ctl->counter_bits[i];
            SUBDBG("event=%d, index=%d, val=%lld\n", i, index, _appio_register_current[index]);
            appio_ctl->values[index] = _appio_register_current[index];
    }
    *events = appio_ctl->values;
 
    return PAPI_OK;
}

_appio_reset()

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

static

Definition at line 627 of file appio.c.

{
    ( void ) ctx;
    ( void ) ctl;
 
    return PAPI_OK;
}

_appio_set_domain()

static int _appio_set_domain ( hwd_control_state_t *  ctl, int  domain  )

static

Definition at line 611 of file appio.c.

{
    ( void ) ctl;
 
    int found = 0;
 
    if ( PAPI_DOM_USER == domain )   found = 1;
 
    if ( !found )
        return PAPI_EINVAL;
 
    return PAPI_OK;
}

_appio_shutdown_component()

static int _appio_shutdown_component ( void  )

static

Definition at line 554 of file appio.c.

{
    papi_free( _appio_native_events );
    return PAPI_OK;
}

_appio_shutdown_thread()

static int _appio_shutdown_thread ( hwd_context_t *  ctx )

static

Definition at line 542 of file appio.c.

{
    ( void ) ctx;
 
    return PAPI_OK;
}

_appio_start()

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

static

Definition at line 481 of file appio.c.

{
    ( void ) ctx;
 
    SUBDBG("_appio_start %p %p\n", ctx, ctl);
    APPIO_control_state_t *appio_ctl = (APPIO_control_state_t *) ctl;
 
    /* this memset needs to move to thread_init */
    memset(_appio_register_current, 0, APPIO_MAX_COUNTERS * sizeof(_appio_register_current[0]));
 
    /* set initial values to 0 */
    memset(appio_ctl->values, 0, APPIO_MAX_COUNTERS*sizeof(appio_ctl->values[0]));
    
    return PAPI_OK;
}

_appio_stop()

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

static

Definition at line 521 of file appio.c.

{
    (void) ctx;
 
    SUBDBG("_appio_stop ctx=%p ctl=%p\n", ctx, ctl);
    APPIO_control_state_t *appio_ctl = (APPIO_control_state_t *) ctl;
    int i;
    for ( i=0; i<appio_ctl->num_events; i++ ) {
            int index = appio_ctl->counter_bits[i];
            SUBDBG("event=%d, index=%d, val=%lld\n", i, index, _appio_register_current[index]);
            appio_ctl->values[i] = _appio_register_current[index];
    }
 
    return PAPI_OK;
}

_appio_update_control_state()

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

static

Definition at line 578 of file appio.c.

{
    ( void ) ctx;
    ( void ) ctl;
 
    SUBDBG("_appio_update_control_state ctx=%p ctl=%p num_events=%d\n", ctx, ctl, count);
    int i, index;
    APPIO_control_state_t *appio_ctl = (APPIO_control_state_t *) ctl;
    (void) ctx;
 
    for ( i = 0; i < count; i++ ) {
        index = native[i].ni_event;
        appio_ctl->counter_bits[i] = index;
        native[i].ni_position = index;
    }
    appio_ctl->num_events = count;
 
    return PAPI_OK;
}

_IO_fread()

size_t _IO_fread	(	void *	ptr,
		size_t	size,
		size_t	nmemb,
		FILE *	stream
	)

Here is the caller graph for this function:

_IO_fwrite()

size_t _IO_fwrite	(	const void *	ptr,
		size_t	size,
		size_t	nmemb,
		FILE *	stream
	)

Here is the caller graph for this function:

close()

int close

(

int

fd

)

Definition at line 179 of file appio.c.

                  {
  int retval;
  SUBDBG("appio: intercepted close(%d)\n", fd);
  retval = __close(fd);
  if ((retval == 0) && (_appio_register_current[OPEN_FDS]>0)) _appio_register_current[OPEN_FDS]--;
  return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

fread()

size_t fread	(	void *	ptr,
		size_t	size,
		size_t	nmemb,
		FILE *	stream
	)

Definition at line 279 of file appio.c.

                                                                 {
  size_t retval;
  SUBDBG("appio: intercepted fread(%p,%lu,%lu,%p)\n", ptr, (unsigned long) size, (unsigned long) nmemb, (void*) stream);
  long long start_ts = PAPI_get_real_usec();
  retval = _IO_fread(ptr,size,nmemb,stream);
  long long duration = PAPI_get_real_usec() - start_ts;
  int n = _appio_register_current[READ_CALLS]++; // read calls
  if (retval > 0) {
    _appio_register_current[READ_BLOCK_SIZE]= (n * _appio_register_current[READ_BLOCK_SIZE]+ size*nmemb)/(n+1);//mean size
    _appio_register_current[READ_BYTES]+= retval * size; // read bytes
    if (retval < nmemb) _appio_register_current[READ_SHORT]++; // read short
    _appio_register_current[READ_USEC] += duration;
  }
 
  /* A value of zero returned means one of two things..*/
  if (retval == 0) {
     if (feof(stream)) _appio_register_current[READ_EOF]++; // read eof
     else _appio_register_current[READ_ERR]++; // read err
  }
  return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

fwrite()

size_t fwrite	(	const void *	ptr,
		size_t	size,
		size_t	nmemb,
		FILE *	stream
	)

Definition at line 391 of file appio.c.

                                                                        {
  size_t retval;
  SUBDBG("appio: intercepted fwrite(%p,%lu,%lu,%p)\n", ptr, (unsigned long) size, (unsigned long) nmemb, (void*) stream);
  long long start_ts = PAPI_get_real_usec();
  retval = _IO_fwrite(ptr,size,nmemb,stream);
  long long duration = PAPI_get_real_usec() - start_ts;
  int n = _appio_register_current[WRITE_CALLS]++; // write calls
  if (retval > 0) {
    _appio_register_current[WRITE_BLOCK_SIZE]= (n * _appio_register_current[WRITE_BLOCK_SIZE] + size*nmemb)/(n+1); // mean block size
    _appio_register_current[WRITE_BYTES]+= retval * size; // write bytes
    if (retval < nmemb) _appio_register_current[WRITE_SHORT]++; // short write
    _appio_register_current[WRITE_USEC] += duration;
  }
  if (retval == 0) _appio_register_current[WRITE_ERR]++; // err
  return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

lseek()

off_t lseek	(	int	fd,
		off_t	offset,
		int	whence
	)

Definition at line 214 of file appio.c.

                                              {
  off_t retval;
  SUBDBG("appio: intercepted lseek(%d,%ld,%d)\n", fd, offset, whence);
  long long start_ts = PAPI_get_real_usec();
  retval = __lseek(fd, offset, whence);
  long long duration = PAPI_get_real_usec() - start_ts;
  int n = _appio_register_current[SEEK_CALLS]++;
  _appio_register_current[SEEK_USEC] += duration;
  if (offset < 0) offset = -offset; // get abs offset
  _appio_register_current[SEEK_ABS_STRIDE_SIZE]= (n * _appio_register_current[SEEK_ABS_STRIDE_SIZE] + offset)/(n+1); // mean absolute stride size
  return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

open()

int open	(	const char *	pathname,
		int	flags,
		mode_t	mode
	)

Definition at line 188 of file appio.c.

                                                       {
  int retval;
  SUBDBG("appio: intercepted open(%s,%d,%d)\n", pathname, flags, mode);
  retval = __open(pathname,flags,mode);
  _appio_register_current[OPEN_CALLS]++;
  if (retval < 0) _appio_register_current[OPEN_ERR]++;
  else _appio_register_current[OPEN_FDS]++;
  return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

read()

ssize_t read	(	int	fd,
		void *	buf,
		size_t	count
	)

Definition at line 229 of file appio.c.

                                              {
  int retval;
  SUBDBG("appio: intercepted read(%d,%p,%lu)\n", fd, buf, (unsigned long)count);
 
  struct stat st;
  int issocket = 0;
  if (fstat(fd, &st) == 0) {
    if ((st.st_mode & S_IFMT) == S_IFSOCK) issocket = 1;
  }
  // check if read would block on descriptor
  fd_set readfds;
  FD_ZERO(&readfds);
  FD_SET(fd, &readfds);
  int ready = __select(fd+1, &readfds, NULL, NULL, &zerotv);
  if (ready == 0) {
     _appio_register_current[READ_WOULD_BLOCK]++; 
     if (issocket) _appio_register_current[SOCK_READ_WOULD_BLOCK]++; 
  }
 
  long long start_ts = PAPI_get_real_usec();
  retval = __read(fd,buf, count);
  long long duration = PAPI_get_real_usec() - start_ts;
  int n = _appio_register_current[READ_CALLS]++; // read calls
  if (issocket) _appio_register_current[SOCK_READ_CALLS]++; // read calls
  if (retval > 0) {
    _appio_register_current[READ_BLOCK_SIZE]= (n * _appio_register_current[READ_BLOCK_SIZE] + count)/(n+1); // mean size
    _appio_register_current[READ_BYTES] += retval; // read bytes
    if (issocket) _appio_register_current[SOCK_READ_BYTES] += retval;
    if (retval < (int)count) {
       _appio_register_current[READ_SHORT]++; // read short
       if (issocket) _appio_register_current[SOCK_READ_SHORT]++; // read short
    }
    _appio_register_current[READ_USEC] += duration;
    if (issocket) _appio_register_current[SOCK_READ_USEC] += duration;
  }
  if (retval < 0) { 
    _appio_register_current[READ_ERR]++; // read err
    if (issocket) _appio_register_current[SOCK_READ_ERR]++; // read err
    if (EINTR == errno)
      _appio_register_current[READ_INTERRUPTED]++; // signal interrupted the read
    //if ((EAGAIN == errno) || (EWOULDBLOCK == errno)) {
    //  _appio_register_current[READ_WOULD_BLOCK]++; //read would block on descriptor marked as non-blocking
    //  if (issocket) _appio_register_current[SOCK_READ_WOULD_BLOCK]++; //read would block on descriptor marked as non-blocking
    //}
  }
  if (retval == 0) _appio_register_current[READ_EOF]++; // read eof
  return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

select()

int select	(	int	nfds,
		fd_set *	readfds,
		fd_set *	writefds,
		fd_set *	exceptfds,
		struct timeval *	timeout
	)

Definition at line 203 of file appio.c.

                                                                                                    {
  int retval;
  SUBDBG("appio: intercepted select(%d,%p,%p,%p,%p)\n", nfds,readfds,writefds,exceptfds,timeout);
  long long start_ts = PAPI_get_real_usec();
  retval = __select(nfds,readfds,writefds,exceptfds,timeout);
  long long duration = PAPI_get_real_usec() - start_ts;
  _appio_register_current[SELECT_USEC] += duration;
  return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

write()

ssize_t write	(	int	fd,
		const void *	buf,
		size_t	count
	)

Definition at line 302 of file appio.c.

                                                     {
  int retval;
  SUBDBG("appio: intercepted write(%d,%p,%lu)\n", fd, buf, (unsigned long)count);
  struct stat st;
  int issocket = 0;
  if (fstat(fd, &st) == 0) {
    if ((st.st_mode & S_IFMT) == S_IFSOCK) issocket = 1;
  }
 
  // check if write would block on descriptor
  fd_set writefds;
  FD_ZERO(&writefds);
  FD_SET(fd, &writefds);
  int ready = __select(fd+1, NULL, &writefds, NULL, &zerotv);
  if (ready == 0) {
    _appio_register_current[WRITE_WOULD_BLOCK]++; 
    if (issocket) _appio_register_current[SOCK_WRITE_WOULD_BLOCK]++; 
  }
 
  long long start_ts = PAPI_get_real_usec();
  retval = __write(fd,buf, count);
  long long duration = PAPI_get_real_usec() - start_ts;
  int n = _appio_register_current[WRITE_CALLS]++; // write calls
  if (issocket) _appio_register_current[SOCK_WRITE_CALLS]++; // socket write
  if (retval >= 0) {
    _appio_register_current[WRITE_BLOCK_SIZE]= (n * _appio_register_current[WRITE_BLOCK_SIZE] + count)/(n+1); // mean size
    _appio_register_current[WRITE_BYTES]+= retval; // write bytes
    if (issocket) _appio_register_current[SOCK_WRITE_BYTES] += retval;
    if (retval < (int)count) {
      _appio_register_current[WRITE_SHORT]++; // short write
      if (issocket) _appio_register_current[SOCK_WRITE_SHORT]++; 
    }
    _appio_register_current[WRITE_USEC] += duration;
    if (issocket) _appio_register_current[SOCK_WRITE_USEC] += duration;
  }
  if (retval < 0) {
    _appio_register_current[WRITE_ERR]++; // err
    if (issocket) _appio_register_current[SOCK_WRITE_ERR]++;
    if (EINTR == errno)
      _appio_register_current[WRITE_INTERRUPTED]++; // signal interrupted the op
    //if ((EAGAIN == errno) || (EWOULDBLOCK == errno)) {
    //  _appio_register_current[WRITE_WOULD_BLOCK]++; //op would block on descriptor marked as non-blocking
    //  if (issocket) _appio_register_current[SOCK_WRITE_WOULD_BLOCK]++;
    //}
  }
  return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

_appio_counter_info

const struct appio_counters _appio_counter_info[APPIO_MAX_COUNTERS]

static

_appio_native_events

APPIO_native_event_entry_t* _appio_native_events

static

Definition at line 65 of file appio.c.

_appio_register_current

__thread long long _appio_register_current[APPIO_MAX_COUNTERS]

static

Definition at line 69 of file appio.c.

_appio_vector

papi_vector_t _appio_vector

Definition at line 57 of file appio.c.

errno

int errno

extern

zerotv

struct timeval zerotv

Definition at line 200 of file appio.c.