linux-memory.c File Reference

Include dependency graph for linux-memory.c:

Go to the source code of this file.

Functions
int	generic_get_memory_info (PAPI_hw_info_t *hw_info)
int	_linux_get_dmem_info (PAPI_dmem_info_t *d)
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 50 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 1454 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);
#elif defined(__aarch64__)
    aarch64_get_memory_info( hwinfo );
#else
        generic_get_memory_info (hwinfo);
#endif
 
    return retval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

_linux_update_shlib_info()

int _linux_update_shlib_info

(

papi_mdi_t *

mdi

)

Definition at line 1480 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 =
                        ( vptr_t ) begin;
                    mdi->exe_info.address_info.text_end =
                        ( vptr_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 =
                    ( vptr_t ) begin;
                mdi->exe_info.address_info.data_end =
                    ( vptr_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 =
                    ( vptr_t ) begin;
                mdi->exe_info.address_info.bss_end =
                    ( vptr_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 = ( vptr_t ) begin;
                    tmp[t_index - 1].text_end = ( vptr_t ) ( begin + size );
                    strncpy( tmp[t_index - 1].name, mapname, PAPI_HUGE_STR_LEN );
               tmp[t_index - 1].name[PAPI_HUGE_STR_LEN-1]=0;
                }
            } 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 = ( vptr_t ) begin;
                    tmp[t_index - 1].data_end = ( vptr_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 = ( vptr_t ) begin;
                    tmp[t_index - 1].bss_end = ( vptr_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:

Here is the caller graph for this function:

generic_get_memory_info()

int generic_get_memory_info

(

PAPI_hw_info_t *

hw_info

)

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

{
 
    int type=0,level,result;
    int size,line_size,associativity,sets;
    int write_policy,allocation_policy;
    DIR *dir;
    FILE *fff;
    char filename[BUFSIZ],type_string[BUFSIZ];
    char *str_result;
    char write_policy_string[BUFSIZ],allocation_policy_string[BUFSIZ];
    struct dirent *d;
    int max_level=0;
    int level_count,level_index;
 
    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;
    }
 
    for (level_index=0; level_index < PAPI_MAX_MEM_HIERARCHY_LEVELS; ++level_index) {
        for (level_count = 0; level_count < PAPI_MH_MAX_LEVELS; ++level_count) {
            L[level_index].cache[level_count].type = PAPI_MH_TYPE_EMPTY;
        }
    }
 
    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;
 
        level_count = 0;
        while (L[level_index].cache[level_count].type != PAPI_MH_TYPE_EMPTY) {
            level_count++;
            if (level_count>=PAPI_MH_MAX_LEVELS) {
                break;
            }
        }
 
        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;
        }
        str_result=fgets(type_string, BUFSIZ, fff);
        fclose(fff);
        if (str_result==NULL) {
            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;
        }
 
        /********************/
        /* Get write_policy */
        /********************/
        write_policy=0;
        sprintf(filename,
            "/sys/devices/system/cpu/cpu0/cache/%s/write_policy",d->d_name);
        fff=fopen(filename,"r");
        if (fff==NULL) {
            MEMDBG("Cannot open write_policy\n");
            goto get_allocation_policy;
        }
        str_result=fgets(write_policy_string, BUFSIZ, fff);
        fclose(fff);
        if (str_result==NULL) {
            MEMDBG("Could not read cache write_policy\n");
            goto get_allocation_policy;
        }
        if (!strcmp(write_policy_string,"WriteThrough")) {
            write_policy=PAPI_MH_TYPE_WT;
        }
        if (!strcmp(write_policy_string,"WriteBack")) {
            write_policy=PAPI_MH_TYPE_WB;
        }
 
get_allocation_policy:
 
        /*************************/
        /* Get allocation_policy */
        /*************************/
        allocation_policy=0;
        sprintf(filename,
            "/sys/devices/system/cpu/cpu0/cache/%s/allocation_policy",d->d_name);
        fff=fopen(filename,"r");
        if (fff==NULL) {
            MEMDBG("Cannot open allocation_policy\n");
            goto get_size;
        }
        str_result=fgets(allocation_policy_string, BUFSIZ, fff);
        fclose(fff);
        if (str_result==NULL) {
            MEMDBG("Could not read cache allocation_policy\n");
            goto get_size;
        }
        if (!strcmp(allocation_policy_string,"ReadAllocate")) {
            allocation_policy=PAPI_MH_TYPE_RD_ALLOC;
        }
        if (!strcmp(allocation_policy_string,"WriteAllocate")) {
            allocation_policy=PAPI_MH_TYPE_WR_ALLOC;
        }
        if (!strcmp(allocation_policy_string,"ReadWriteAllocate")) {
            allocation_policy=PAPI_MH_TYPE_RW_ALLOC;
        }
 
get_size:
        L[level_index].cache[level_count].type=type | write_policy | allocation_policy;
 
        /*************/
        /* 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 */
        /*************/
        L[level_index].cache[level_count].line_size=0;
 
        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");
        }
        else {
            result=fscanf(fff,"%d",&line_size);
            fclose(fff);
            if (result!=1) {
                MEMDBG("Could not read cache line-size\n");
            } else {
                L[level_index].cache[level_count].line_size=line_size;
            }
        }
 
 
        /*********************/
        /* Get Associativity */
        /*********************/
        L[level_index].cache[level_count].associativity=0;
 
        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");
        }
        else {
            result=fscanf(fff,"%d",&associativity);
            fclose(fff);
            if (result!=1) {
                MEMDBG("Could not read cache associativity\n");
            }
            else {
                L[level_index].cache[level_count].associativity=associativity;
            }
        }
 
        /************/
        /* Get Sets */
        /************/
        L[level_index].cache[level_count].num_lines=0;
 
        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");
        }
        else {
            result=fscanf(fff,"%d",&sets);
            fclose(fff);
 
            if (result!=1) {
                MEMDBG("Could not read cache sets\n");
            }
            else {
                L[level_index].cache[level_count].num_lines=sets;
            }
        }
 
        /* Sanity check results */
        if ((line_size!=0) && (associativity!=0)) {
            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;
        }
    }
 
   closedir(dir);
    hw_info->mem_hierarchy.levels = max_level;
 
    return 0;
 
unrecoverable_error:
 
    /* Just say we have no cache */
    hw_info->mem_hierarchy.levels = 0;
 
   closedir(dir);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function: