linux-memory.c File Reference

Include dependency graph for linux-memory.c:

Go to the source code of this file.

Functions
int	_linux_get_dmem_info (PAPI_dmem_info_t *d)
int	generic_get_memory_info (PAPI_hw_info_t *hw_info)
int	_linux_get_memory_info (PAPI_hw_info_t *hwinfo, int cpu_type)
int	_linux_update_shlib_info (papi_mdi_t *mdi)

Function Documentation

_linux_get_dmem_info()

int _linux_get_dmem_info

(

PAPI_dmem_info_t *

d

)

Definition at line 48 of file linux-memory.c.

{
    char fn[PATH_MAX], tmp[PATH_MAX];
    FILE *f;
    int ret;
    long long sz = 0, lck = 0, res = 0, shr = 0, stk = 0, txt = 0, dat =
        0, dum = 0, lib = 0, hwm = 0;

    sprintf( fn, "/proc/%ld/status", ( long ) getpid(  ) );
    f = fopen( fn, "r" );
    if ( f == NULL ) {
        PAPIERROR( "fopen(%s): %s\n", fn, strerror( errno ) );
        return PAPI_ESYS;
    }
    while ( 1 ) {
        if ( fgets( tmp, PATH_MAX, f ) == NULL )
            break;
        if ( strspn( tmp, "VmSize:" ) == strlen( "VmSize:" ) ) {
            sscanf( tmp + strlen( "VmSize:" ), "%lld", &sz );
            d->size = sz;
            continue;
        }
        if ( strspn( tmp, "VmHWM:" ) == strlen( "VmHWM:" ) ) {
            sscanf( tmp + strlen( "VmHWM:" ), "%lld", &hwm );
            d->high_water_mark = hwm;
            continue;
        }
        if ( strspn( tmp, "VmLck:" ) == strlen( "VmLck:" ) ) {
            sscanf( tmp + strlen( "VmLck:" ), "%lld", &lck );
            d->locked = lck;
            continue;
        }
        if ( strspn( tmp, "VmRSS:" ) == strlen( "VmRSS:" ) ) {
            sscanf( tmp + strlen( "VmRSS:" ), "%lld", &res );
            d->resident = res;
            continue;
        }
        if ( strspn( tmp, "VmData:" ) == strlen( "VmData:" ) ) {
            sscanf( tmp + strlen( "VmData:" ), "%lld", &dat );
            d->heap = dat;
            continue;
        }
        if ( strspn( tmp, "VmStk:" ) == strlen( "VmStk:" ) ) {
            sscanf( tmp + strlen( "VmStk:" ), "%lld", &stk );
            d->stack = stk;
            continue;
        }
        if ( strspn( tmp, "VmExe:" ) == strlen( "VmExe:" ) ) {
            sscanf( tmp + strlen( "VmExe:" ), "%lld", &txt );
            d->text = txt;
            continue;
        }
        if ( strspn( tmp, "VmLib:" ) == strlen( "VmLib:" ) ) {
            sscanf( tmp + strlen( "VmLib:" ), "%lld", &lib );
            d->library = lib;
            continue;
        }
    }
    fclose( f );

    sprintf( fn, "/proc/%ld/statm", ( long ) getpid(  ) );
    f = fopen( fn, "r" );
    if ( f == NULL ) {
        PAPIERROR( "fopen(%s): %s\n", fn, strerror( errno ) );
        return PAPI_ESYS;
    }
    ret =
        fscanf( f, "%lld %lld %lld %lld %lld %lld %lld", &dum, &dum, &shr, &dum,
                &dum, &dat, &dum );
    if ( ret != 7 ) {
        PAPIERROR( "fscanf(7 items): %d\n", ret );
        fclose(f);
        return PAPI_ESYS;
    }
    d->pagesize = getpagesize(  );
    d->shared = ( shr * d->pagesize ) / 1024;
    fclose( f );

    return PAPI_OK;
}

Here is the call graph for this function:

_linux_get_memory_info()

int _linux_get_memory_info	(	PAPI_hw_info_t *	hwinfo,
		int	cpu_type
	)

Definition at line 1110 of file linux-memory.c.

{
    ( void ) cpu_type;       /*unused */
    int retval = PAPI_OK;

#if defined(__i386__)||defined(__x86_64__)
    x86_get_memory_info( hwinfo );
#elif defined(__ia64__)
    ia64_get_memory_info( hwinfo );
#elif defined(__powerpc__)
    ppc64_get_memory_info( hwinfo );
#elif defined(__sparc__)
    sparc_get_memory_info( hwinfo );
#elif defined(__arm__)
    #warning "WARNING! linux_get_memory_info() does nothing on ARM32!"
        generic_get_memory_info (hwinfo);
#else
        generic_get_memory_info (hwinfo);
#endif

    return retval;
}

Here is the call graph for this function:

_linux_update_shlib_info()

int _linux_update_shlib_info

(

papi_mdi_t *

mdi

)

Definition at line 1134 of file linux-memory.c.

{

    char fname[PAPI_HUGE_STR_LEN];
    unsigned long t_index = 0, d_index = 0, b_index = 0, counting = 1;
    char buf[PAPI_HUGE_STR_LEN + PAPI_HUGE_STR_LEN], perm[5], dev[16];
    char mapname[PAPI_HUGE_STR_LEN], lastmapname[PAPI_HUGE_STR_LEN];
    unsigned long begin = 0, end = 0, size = 0, inode = 0, foo = 0;
    PAPI_address_map_t *tmp = NULL;
    FILE *f;

    memset( fname, 0x0, sizeof ( fname ) );
    memset( buf, 0x0, sizeof ( buf ) );
    memset( perm, 0x0, sizeof ( perm ) );
    memset( dev, 0x0, sizeof ( dev ) );
    memset( mapname, 0x0, sizeof ( mapname ) );
    memset( lastmapname, 0x0, sizeof ( lastmapname ) );

    sprintf( fname, "/proc/%ld/maps", ( long ) mdi->pid );
    f = fopen( fname, "r" );

    if ( !f ) {
        PAPIERROR( "fopen(%s) returned < 0", fname );
        return PAPI_OK;
    }

  again:
    while ( !feof( f ) ) {
        begin = end = size = inode = foo = 0;
        if ( fgets( buf, sizeof ( buf ), f ) == 0 )
            break;
        /* If mapname is null in the string to be scanned, we need to detect that */
        if ( strlen( mapname ) )
            strcpy( lastmapname, mapname );
        else
            lastmapname[0] = '\0';
        /* If mapname is null in the string to be scanned, we need to detect that */
        mapname[0] = '\0';
        sscanf( buf, "%lx-%lx %4s %lx %s %ld %s", &begin, &end, perm, &foo, dev,
                &inode, mapname );
        size = end - begin;

        /* the permission string looks like "rwxp", where each character can
         * be either the letter, or a hyphen.  The final character is either
         * p for private or s for shared. */

        if ( counting ) {
            if ( ( perm[2] == 'x' ) && ( perm[0] == 'r' ) && ( inode != 0 ) ) {
                if ( strcmp( mdi->exe_info.fullname, mapname )
                     == 0 ) {
                    mdi->exe_info.address_info.text_start =
                        ( caddr_t ) begin;
                    mdi->exe_info.address_info.text_end =
                        ( caddr_t ) ( begin + size );
                }
                t_index++;
            } else if ( ( perm[0] == 'r' ) && ( perm[1] == 'w' ) &&
                        ( inode != 0 )
                        &&
                        ( strcmp
                          ( mdi->exe_info.fullname,
                            mapname ) == 0 ) ) {
                mdi->exe_info.address_info.data_start =
                    ( caddr_t ) begin;
                mdi->exe_info.address_info.data_end =
                    ( caddr_t ) ( begin + size );
                d_index++;
            } else if ( ( perm[0] == 'r' ) && ( perm[1] == 'w' ) &&
                        ( inode == 0 )
                        &&
                        ( strcmp
                          ( mdi->exe_info.fullname,
                            lastmapname ) == 0 ) ) {
                mdi->exe_info.address_info.bss_start =
                    ( caddr_t ) begin;
                mdi->exe_info.address_info.bss_end =
                    ( caddr_t ) ( begin + size );
                b_index++;
            }
        } else if ( !counting ) {
            if ( ( perm[2] == 'x' ) && ( perm[0] == 'r' ) && ( inode != 0 ) ) {
                if ( strcmp( mdi->exe_info.fullname, mapname )
                     != 0 ) {
                    t_index++;
                    tmp[t_index - 1].text_start = ( caddr_t ) begin;
                    tmp[t_index - 1].text_end = ( caddr_t ) ( begin + size );
                    strncpy( tmp[t_index - 1].name, mapname, PAPI_MAX_STR_LEN );
                }
            } else if ( ( perm[0] == 'r' ) && ( perm[1] == 'w' ) &&
                        ( inode != 0 ) ) {
                if ( ( strcmp
                       ( mdi->exe_info.fullname,
                         mapname ) != 0 )
                     && ( t_index > 0 ) &&
                     ( tmp[t_index - 1].data_start == 0 ) ) {
                    tmp[t_index - 1].data_start = ( caddr_t ) begin;
                    tmp[t_index - 1].data_end = ( caddr_t ) ( begin + size );
                }
            } else if ( ( perm[0] == 'r' ) && ( perm[1] == 'w' ) &&
                        ( inode == 0 ) ) {
                if ( ( t_index > 0 ) && ( tmp[t_index - 1].bss_start == 0 ) ) {
                    tmp[t_index - 1].bss_start = ( caddr_t ) begin;
                    tmp[t_index - 1].bss_end = ( caddr_t ) ( begin + size );
                }
            }
        }
    }

    if ( counting ) {
        /* When we get here, we have counted the number of entries in the map
           for us to allocate */

        tmp =
            ( PAPI_address_map_t * ) papi_calloc( t_index,
                                                  sizeof
                                                  ( PAPI_address_map_t ) );
        if ( tmp == NULL ) {
            PAPIERROR( "Error allocating shared library address map" );
            fclose(f);
            return PAPI_ENOMEM;
        }
        t_index = 0;
        rewind( f );
        counting = 0;
        goto again;
    } else {
        if ( mdi->shlib_info.map )
            papi_free( mdi->shlib_info.map );
        mdi->shlib_info.map = tmp;
        mdi->shlib_info.count = t_index;

        fclose( f );
    }

    return PAPI_OK;
}

Here is the call graph for this function:

generic_get_memory_info()

int generic_get_memory_info

(

PAPI_hw_info_t *

hw_info

)

Definition at line 900 of file linux-memory.c.

{

    int type=0,level,result;
    int size,line_size,associativity,sets;
    DIR *dir;
    FILE *fff;
    char filename[BUFSIZ],type_string[BUFSIZ];
    struct dirent *d;
    int max_level=0;
    int level_count=0,last_level=-1,level_index=0;

    PAPI_mh_level_t *L = hw_info->mem_hierarchy.level;

    /* open Linux cache dir         */
    /* assume all CPUs same as cpu0.    */
    /* Not necessarily a good assumption    */

    dir=opendir("/sys/devices/system/cpu/cpu0/cache");
    if (dir==NULL) {
        goto unrecoverable_error;
    }

    while(1) {
        d = readdir(dir);
        if (d==NULL) break;

        if (strncmp(d->d_name, "index", 5)) continue;

        MEMDBG("Found %s\n",d->d_name);

        /*************/
        /* Get level */
        /*************/
        sprintf(filename,
            "/sys/devices/system/cpu/cpu0/cache/%s/level",
            d->d_name);
        fff=fopen(filename,"r");
        if (fff==NULL) {
            MEMDBG("Cannot open level.\n");
            goto unrecoverable_error;
        }

        result=fscanf(fff,"%d",&level);
        fclose(fff);
        if (result!=1) {
            MEMDBG("Could not read cache level\n");
            goto unrecoverable_error;
        }

        /* Index arrays from 0 */
        level_index=level-1;

        if (level!=last_level) {
            level_count=0;
            last_level=level;
        } else {
            level_count++;
        }

        if (level_count>=PAPI_MH_MAX_LEVELS) {
            MEMDBG("Exceeded maximum levels %d\n",
                PAPI_MH_MAX_LEVELS);
            break;
        }

        /************/
        /* Get type */
        /************/
        sprintf(filename,
            "/sys/devices/system/cpu/cpu0/cache/%s/type",d->d_name);
        fff=fopen(filename,"r");
        if (fff==NULL) {
            MEMDBG("Cannot open type\n");
            goto unrecoverable_error;
        }
        result=fscanf(fff,"%s",type_string);
        fclose(fff);
        if (result!=1) {
            MEMDBG("Could not read cache type\n");
            goto unrecoverable_error;
        }
        if (!strcmp(type_string,"Data")) {
            type=PAPI_MH_TYPE_DATA;
        }
        if (!strcmp(type_string,"Instruction")) {
            type=PAPI_MH_TYPE_INST;
        }
        if (!strcmp(type_string,"Unified")) {
            type=PAPI_MH_TYPE_UNIFIED;
        }
        L[level_index].cache[level_count].type=type;

        /*************/
        /* Get Size  */
        /*************/
        sprintf(filename,
            "/sys/devices/system/cpu/cpu0/cache/%s/size",d->d_name);
        fff=fopen(filename,"r");
        if (fff==NULL) {
            MEMDBG("Cannot open size\n");
            goto unrecoverable_error;
        }
        result=fscanf(fff,"%d",&size);
        fclose(fff);
        if (result!=1) {
            MEMDBG("Could not read cache size\n");
            goto unrecoverable_error;
        }

        /* Linux reports in kB, PAPI expects in Bytes */
        L[level_index].cache[level_count].size=size*1024;

        /*************/
        /* Line Size */
        /*************/
        sprintf(filename,
            "/sys/devices/system/cpu/cpu0/cache/%s/coherency_line_size",
            d->d_name);
        fff=fopen(filename,"r");
        if (fff==NULL) {
            MEMDBG("Cannot open linesize\n");
            goto unrecoverable_error;
        }
        result=fscanf(fff,"%d",&line_size);
        fclose(fff);
        if (result!=1) {
            MEMDBG("Could not read cache line-size\n");
            goto unrecoverable_error;
        }
        L[level_index].cache[level_count].line_size=line_size;


        /*********************/
        /* Get Associativity */
        /*********************/
        sprintf(filename,
            "/sys/devices/system/cpu/cpu0/cache/%s/ways_of_associativity",
            d->d_name);
        fff=fopen(filename,"r");
        if (fff==NULL) {
            MEMDBG("Cannot open associativity\n");
            goto unrecoverable_error;
        }
        result=fscanf(fff,"%d",&associativity);
        fclose(fff);
        if (result!=1) {
            MEMDBG("Could not read cache associativity\n");
            goto unrecoverable_error;
        }
        L[level_index].cache[level_count].associativity=associativity;

        /************/
        /* Get Sets */
        /************/
        sprintf(filename,
            "/sys/devices/system/cpu/cpu0/cache/%s/number_of_sets",
            d->d_name);
        fff=fopen(filename,"r");
        if (fff==NULL) {
            MEMDBG("Cannot open sets\n");
            goto unrecoverable_error;
        }
        result=fscanf(fff,"%d",&sets);
        fclose(fff);

        if (result!=1) {
            MEMDBG("Could not read cache sets\n");
            goto unrecoverable_error;
        }
        L[level_index].cache[level_count].num_lines=sets;


        if (((size*1024)/line_size/associativity)!=sets) {
            MEMDBG("Warning!  sets %d != expected %d\n",
                sets,((size*1024)/line_size/associativity));
        }

        MEMDBG("\tL%d %s cache\n",level,type_string);
        MEMDBG("\t%d kilobytes\n",size);
        MEMDBG("\t%d byte linesize\n",line_size);
        MEMDBG("\t%d-way associative\n",associativity);
        MEMDBG("\t%d lines\n",sets);
        MEMDBG("\tUnknown inclusivity\n");
        MEMDBG("\tUnknown replacement algorithm\n");
        MEMDBG("\tUnknown if victim cache\n");

        if (level>max_level) max_level=level;

                if (level>=PAPI_MAX_MEM_HIERARCHY_LEVELS) {
            MEMDBG("Exceeded maximum cache level %d\n",
                PAPI_MAX_MEM_HIERARCHY_LEVELS);
            break;
        }
    }

    hw_info->mem_hierarchy.levels = max_level;

    return 0;

unrecoverable_error:

    /* Just say we have no cache */
    hw_info->mem_hierarchy.levels = 0;

    return 0;
}

Here is the caller graph for this function: