sde_lib_internal.h File Reference

Include dependency graph for sde_lib_internal.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	cset_hash_decorated_object_t
struct	cset_hash_bucket_t
struct	cset_hash_table_t
struct	papisde_list_entry_t
struct	recorder_data_t
struct	cntr_class_basic_t
struct	cntr_class_callback_t
struct	cntr_class_recorder_t
struct	cntr_class_cset_t
struct	cntr_class_group_t
union	cntr_class_specific_t
struct	sde_counter_t
struct	sde_sorting_params_t
struct	papisde_library_desc_t
struct	papisde_control_t

Macros
#define	EXP_CONTAINER_ENTRIES   52
#define	EXP_CONTAINER_MIN_SIZE   2048
#define	PAPISDE_HT_SIZE   512
#define	is_readonly(_X_)   (PAPI_SDE_RO == ((_X_)&0x0F))
#define	is_readwrite(_X_)   (PAPI_SDE_RW == ((_X_)&0x0F))
#define	is_delta(_X_)   (PAPI_SDE_DELTA == ((_X_)&0xF0))
#define	is_instant(_X_)   (PAPI_SDE_INSTANT == ((_X_)&0xF0))
#define	_SDE_HASH_BUCKET_COUNT_   373
#define	_SDE_HASH_BUCKET_WIDTH_   14
#define	SDE_HASH_IS_FUZZY   0
#define	IS_CNTR_REGISTERED(_CNT)   ( CNTR_CLASS_REGISTERED == (_CNT)->cntr_class )
#define	IS_CNTR_CREATED(_CNT)   ( CNTR_CLASS_CREATED == (_CNT)->cntr_class )
#define	IS_CNTR_BASIC(_CNT)   ( CNTR_CLASS_BASIC & (_CNT)->cntr_class )
#define	IS_CNTR_CALLBACK(_CNT)   ( CNTR_CLASS_CB == (_CNT)->cntr_class )
#define	IS_CNTR_RECORDER(_CNT)   ( CNTR_CLASS_RECORDER == (_CNT)->cntr_class )
#define	IS_CNTR_CSET(_CNT)   ( CNTR_CLASS_CSET == (_CNT)->cntr_class )
#define	IS_CNTR_PLACEHOLDER(_CNT)   ( CNTR_CLASS_PLACEHOLDER == (_CNT)->cntr_class )
#define	IS_CNTR_GROUP(_CNT)   ( CNTR_CLASS_GROUP == (_CNT)->cntr_class )
#define	mix(h)

Enumerations
enum	CNTR_CLASS {   CNTR_CLASS_REGISTERED = 0x1 , CNTR_CLASS_CREATED = 0x2 , CNTR_CLASS_BASIC = 0x3 , CNTR_CLASS_CB = 0x4 ,   CNTR_CLASS_RECORDER = 0x8 , CNTR_CLASS_CSET = 0x10 , CNTR_CLASS_PLACEHOLDER = 0x1000 , CNTR_CLASS_GROUP = 0x2000 }

Functions
int	sdei_setup_counter_internals (papi_handle_t handle, const char *event_name, int cntr_mode, int cntr_type, enum CNTR_CLASS cntr_class, cntr_class_specific_t cntr_union)
int	sdei_delete_counter (papisde_library_desc_t *lib_handle, const char *name)
int	sdei_inc_ref_count (sde_counter_t *counter)
int	sdei_read_counter_group (sde_counter_t *counter, long long int *rslt_ptr)
void	sdei_counting_set_to_list (void *cset_handle, cset_list_object_t **list_head)
int	sdei_read_and_update_data_value (sde_counter_t *counter, long long int previous_value, long long int *rslt_ptr)
int	sdei_hardware_write (sde_counter_t *counter, long long int new_value)
int	sdei_set_timer_for_overflow (void)
papisde_control_t *	sdei_get_global_struct (void)
sde_counter_t *	ht_lookup_by_id (papisde_list_entry_t *hash_table, uint32_t uniq_id)
sde_counter_t *	ht_lookup_by_name (papisde_list_entry_t *hash_table, const char *name)
sde_counter_t *	ht_delete (papisde_list_entry_t *hash_table, int ht_key, uint32_t uniq_id)
void	ht_insert (papisde_list_entry_t *hash_table, int ht_key, sde_counter_t *sde_counter)
int	ht_to_array (papisde_list_entry_t *hash_table, sde_counter_t **rslt_array)
uint32_t	ht_hash_name (const char *str)
uint32_t	ht_hash_id (uint32_t uniq_id)
papi_handle_t	do_sde_init (const char *name_of_library, papisde_control_t *gctl)
sde_counter_t *	allocate_and_insert (papisde_control_t *gctl, papisde_library_desc_t *lib_handle, const char *name, uint32_t uniq_id, int cntr_mode, int cntr_type, enum CNTR_CLASS cntr_class, cntr_class_specific_t cntr_union)
void	exp_container_to_contiguous (recorder_data_t *exp_container, void *cont_buffer)
int	exp_container_insert_element (recorder_data_t *exp_container, size_t typesize, const void *value)
void	exp_container_init (sde_counter_t *handle, size_t typesize)
void	papi_sde_counting_set_to_list (void *cset_handle, cset_list_object_t **list_head)
int	cset_insert_elem (cset_hash_table_t *hash_ptr, size_t element_size, size_t hashable_size, const void *element, uint32_t type_id)
int	cset_remove_elem (cset_hash_table_t *hash_ptr, size_t hashable_size, const void *element, uint32_t type_id)
cset_list_object_t *	cset_to_list (cset_hash_table_t *hash_ptr)
int	cset_delete (cset_hash_table_t *hash_ptr)
int	sde_ti_reset_counter (uint32_t)
int	sde_ti_read_counter (uint32_t, long long int *)
int	sde_ti_write_counter (uint32_t, long long)
int	sde_ti_name_to_code (const char *, uint32_t *)
int	sde_ti_is_simple_counter (uint32_t)
int	sde_ti_is_counter_set_to_overflow (uint32_t)
int	sde_ti_set_counter_overflow (uint32_t, int)
char *	sde_ti_get_event_name (int)
char *	sde_ti_get_event_description (int)
int	sde_ti_get_num_reg_events (void)
int	sde_ti_shutdown (void)
static uint64_t	fasthash64 (const void *buf, size_t len, uint64_t seed)

Variables
papisde_control_t *	_papisde_global_control

Detailed Description

Author

Anthony Danalis adana.nosp@m.lis@.nosp@m.icl.u.nosp@m.tk.e.nosp@m.du

Definition in file sde_lib_internal.h.

Macro Definition Documentation

_SDE_HASH_BUCKET_COUNT_

#define _SDE_HASH_BUCKET_COUNT_   373

Definition at line 49 of file sde_lib_internal.h.

_SDE_HASH_BUCKET_WIDTH_

#define _SDE_HASH_BUCKET_WIDTH_   14

Definition at line 50 of file sde_lib_internal.h.

EXP_CONTAINER_ENTRIES

#define EXP_CONTAINER_ENTRIES   52

Definition at line 24 of file sde_lib_internal.h.

EXP_CONTAINER_MIN_SIZE

#define EXP_CONTAINER_MIN_SIZE   2048

Definition at line 25 of file sde_lib_internal.h.

IS_CNTR_BASIC

#define IS_CNTR_BASIC

(

_CNT

)

( CNTR_CLASS_BASIC & (_CNT)->cntr_class )

Definition at line 164 of file sde_lib_internal.h.

IS_CNTR_CALLBACK

#define IS_CNTR_CALLBACK

(

_CNT

)

( CNTR_CLASS_CB == (_CNT)->cntr_class )

Definition at line 165 of file sde_lib_internal.h.

IS_CNTR_CREATED

#define IS_CNTR_CREATED

(

_CNT

)

( CNTR_CLASS_CREATED == (_CNT)->cntr_class )

Definition at line 163 of file sde_lib_internal.h.

IS_CNTR_CSET

#define IS_CNTR_CSET

(

_CNT

)

( CNTR_CLASS_CSET == (_CNT)->cntr_class )

Definition at line 167 of file sde_lib_internal.h.

IS_CNTR_GROUP

#define IS_CNTR_GROUP

(

_CNT

)

( CNTR_CLASS_GROUP == (_CNT)->cntr_class )

Definition at line 169 of file sde_lib_internal.h.

IS_CNTR_PLACEHOLDER

#define IS_CNTR_PLACEHOLDER

(

_CNT

)

( CNTR_CLASS_PLACEHOLDER == (_CNT)->cntr_class )

Definition at line 168 of file sde_lib_internal.h.

IS_CNTR_RECORDER

#define IS_CNTR_RECORDER

(

_CNT

)

( CNTR_CLASS_RECORDER == (_CNT)->cntr_class )

Definition at line 166 of file sde_lib_internal.h.

IS_CNTR_REGISTERED

#define IS_CNTR_REGISTERED

(

_CNT

)

( CNTR_CLASS_REGISTERED == (_CNT)->cntr_class )

Definition at line 162 of file sde_lib_internal.h.

is_delta

#define is_delta

(

_X_

)

(PAPI_SDE_DELTA == ((_X_)&0xF0))

Definition at line 31 of file sde_lib_internal.h.

is_instant

#define is_instant

(

_X_

)

(PAPI_SDE_INSTANT == ((_X_)&0xF0))

Definition at line 32 of file sde_lib_internal.h.

is_readonly

#define is_readonly

(

_X_

)

(PAPI_SDE_RO == ((_X_)&0x0F))

Definition at line 29 of file sde_lib_internal.h.

is_readwrite

#define is_readwrite

(

_X_

)

(PAPI_SDE_RW == ((_X_)&0x0F))

Definition at line 30 of file sde_lib_internal.h.

mix

#define mix

(

h

)

Value:

                 ({                                \
                 (h) ^= (h) >> 23;               \
                 (h) *= 0x2127599bf4325c37ULL;   \
                 (h) ^= (h) >> 47; })

Definition at line 239 of file sde_lib_internal.h.

PAPISDE_HT_SIZE

#define PAPISDE_HT_SIZE   512

Definition at line 27 of file sde_lib_internal.h.

SDE_HASH_IS_FUZZY

#define SDE_HASH_IS_FUZZY   0

Definition at line 58 of file sde_lib_internal.h.

Enumeration Type Documentation

CNTR_CLASS

enum CNTR_CLASS

Enumerator
CNTR_CLASS_REGISTERED
CNTR_CLASS_CREATED
CNTR_CLASS_BASIC
CNTR_CLASS_CB
CNTR_CLASS_RECORDER
CNTR_CLASS_CSET
CNTR_CLASS_PLACEHOLDER
CNTR_CLASS_GROUP

Definition at line 151 of file sde_lib_internal.h.

               {
    CNTR_CLASS_REGISTERED = 0x1,
    CNTR_CLASS_CREATED = 0x2,
    CNTR_CLASS_BASIC = 0x3, // both previous types combined.
    CNTR_CLASS_CB = 0x4,
    CNTR_CLASS_RECORDER = 0x8,
    CNTR_CLASS_CSET = 0x10,
    CNTR_CLASS_PLACEHOLDER = 0x1000,
    CNTR_CLASS_GROUP = 0x2000
};

Function Documentation

allocate_and_insert()

sde_counter_t * allocate_and_insert	(	papisde_control_t *	gctl,
		papisde_library_desc_t *	lib_handle,
		const char *	name,
		uint32_t	uniq_id,
		int	cntr_mode,
		int	cntr_type,
		enum CNTR_CLASS	cntr_class,
		cntr_class_specific_t	cntr_union
	)

Definition at line 112 of file sde_lib_misc.c.

                                                                                                                                                                                                                                 {
 
    // make sure to calloc() the structure, so all the fields which we do not explicitly set remain zero.
    sde_counter_t *item = (sde_counter_t *)calloc(1, sizeof(sde_counter_t));
    if( NULL == item )
        return NULL;
 
    item->u = cntr_union;
    item->cntr_class = cntr_class;
    item->cntr_type = cntr_type;
    item->cntr_mode = cntr_mode;
    item->glb_uniq_id = uniq_id;
    item->name = strdup( name );
    item->description = strdup( name );
    item->which_lib = lib_handle;
 
    (void)ht_insert(lib_handle->lib_counters, ht_hash_name(name), item);
    (void)ht_insert(gctl->all_reg_counters, ht_hash_id(uniq_id), item);
 
    return item;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cset_delete()

int cset_delete

(

cset_hash_table_t *

hash_ptr

)

Definition at line 526 of file sde_lib_datastructures.c.

                                            {
    cset_hash_bucket_t *bucket_ptr;
    int bucket_idx;
    uint32_t i, occupied;
 
    if( NULL == hash_ptr ){
        return SDE_EINVAL;
    }
    bucket_ptr = hash_ptr->buckets;
 
    for( bucket_idx = 0; bucket_idx < _SDE_HASH_BUCKET_COUNT_; bucket_idx++){
        cset_hash_decorated_object_t *obj_ptr = bucket_ptr[bucket_idx].objects;
        occupied = bucket_ptr[bucket_idx].occupied;
        // Free all the elements that occupy entries in this bucket.
        for(i=0; i<occupied; i++){
            free(obj_ptr[i].ptr);
        }
        bucket_ptr[bucket_idx].occupied = 0;
     }
 
    cset_list_object_t *list_runner, *ptr_to_free=NULL;
    // Since there are elements in the overflow list, we need to search for ours.
    for( list_runner = hash_ptr->overflow_list; list_runner != NULL; list_runner = list_runner->next){
        // Free the list element from the previous iteration.
        free(ptr_to_free);
        free(list_runner->ptr);
        // Keep a reference to this element so we can free it _after_ this iteration, because we need the list_runner->next for now.
        ptr_to_free = list_runner;
        // If the current element is at the head of the overflow list, then we should mark the head as NULL.
        if( list_runner == hash_ptr->overflow_list )
            hash_ptr->overflow_list = NULL;
 
    }
    free(ptr_to_free);
 
    return SDE_OK;
}

Here is the caller graph for this function:

cset_insert_elem()

int cset_insert_elem	(	cset_hash_table_t *	hash_ptr,
		size_t	element_size,
		size_t	hashable_size,
		const void *	element,
		uint32_t	type_id
	)

Definition at line 285 of file sde_lib_datastructures.c.

                                                                                                                                   {
    cset_hash_bucket_t *bucket_ptr;
    int element_found = 0;
    uint32_t i, occupied;
    int ret_val;
 
    if( NULL == hash_ptr ){
        ret_val = SDE_EINVAL;
        goto fn_exit;
    }
    bucket_ptr = hash_ptr->buckets;
 
    uint64_t seed = (uint64_t)79365; // decided to be a good seed by a committee.
    uint64_t key = fasthash64(element, hashable_size, seed);
    int bucket_idx = (int)(key % _SDE_HASH_BUCKET_COUNT_);
    uint64_t *key_ptr = bucket_ptr[bucket_idx].keys;
    cset_hash_decorated_object_t *obj_ptr = bucket_ptr[bucket_idx].objects;
    occupied = bucket_ptr[bucket_idx].occupied;
    if( occupied > _SDE_HASH_BUCKET_WIDTH_ ){
        SDE_ERROR("cset_insert_elem(): Counting set is clobbered, bucket %d has exceeded capacity.",bucket_idx);
        ret_val = SDE_ECMP;
        goto fn_exit;
    }
 
    // First look in the bucket where the hash function told us to look.
    for(i=0; i<occupied; i++){
        // If the key and type_id match a stored element and the hashable_size is less or equal to
        // the size of the stored element, then we are onto something.
        if( (key == key_ptr[i]) && (type_id == obj_ptr[i].type_id) && (hashable_size <= obj_ptr[i].type_size) ){
            // If the actual element matches too (or if we don't care about perfect matches),
            // then we update the count for this entry and we are done.
            if( SDE_HASH_IS_FUZZY || !memcmp(element, obj_ptr[i].ptr, hashable_size) ){
                obj_ptr[i].count += 1;
                element_found = 1;
                break;
            }
        }
    }
 
    // If we didn't find the element in the appropriate bucket, then we need to add it (or look in the overflow list).
    if( !element_found ){
        // If the overflow list is empty, then we are certainly dealing with a new element.
        if( NULL == hash_ptr->overflow_list ){
            // Check if we still have room in the bucket, and if so, add the new element to the bucket.
            if( i < _SDE_HASH_BUCKET_WIDTH_ ){
                key_ptr[i] = key;
                obj_ptr[i].count = 1;
                obj_ptr[i].type_id = type_id;
                obj_ptr[i].type_size = element_size;
                obj_ptr[i].ptr = malloc(element_size);
                (void)memcpy(obj_ptr[i].ptr, element, element_size);
                // Let the bucket know that it now has one more element.
                bucket_ptr[bucket_idx].occupied += 1;
            }else{
                // If the overflow list is empty and the bucket does not have room,
                // then we add the new element at the head of the overflow list.
                cset_list_object_t *new_list_element = (cset_list_object_t *)malloc(sizeof(cset_list_object_t));
                new_list_element->next = NULL;
                new_list_element->count = 1;
                new_list_element->type_id = type_id;
                new_list_element->type_size = element_size;
                new_list_element->ptr = malloc(element_size);
                (void)memcpy(new_list_element->ptr, element, element_size);
                // Make the head point to the new element.
                hash_ptr->overflow_list = new_list_element;
            }
        }else{
            // Since there are elements in the overflow list, we need to search there for the one we are looking for.
            cset_list_object_t *list_runner;
            for( list_runner = hash_ptr->overflow_list; list_runner != NULL; list_runner = list_runner->next){
                // if we find the element in the overflow list, increment the counter and exit the loop.
                // When we traverse the overflow list we can _not_ use the SDE_HASH_IS_FUZZY flag, because we
                // don't have matching hashes to indicate that the two elements are close; we are traversing the whole list.
                if( (hashable_size <= list_runner->type_size) && (type_id == list_runner->type_id) && !memcmp(element, list_runner->ptr, hashable_size) ){
                    list_runner->count += 1;
                    break;
                }
            }
            // If we traversed the entire list and didn't find our element, insert it before the current head of the list.
            if( NULL == list_runner ){
                cset_list_object_t *new_list_element = (cset_list_object_t *)malloc(sizeof(cset_list_object_t));
                // Make the new element's "next" pointer be the current head of the list.
                new_list_element->next = hash_ptr->overflow_list;
                new_list_element->count = 1;
                new_list_element->type_id = type_id;
                new_list_element->type_size = element_size;
                new_list_element->ptr = malloc(element_size);
                (void)memcpy(new_list_element->ptr, element, element_size);
                // Update the head of the list to point to the new element.
                hash_ptr->overflow_list = new_list_element;
            }
        }
    }
 
    ret_val = SDE_OK;
fn_exit:
    return ret_val;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cset_remove_elem()

int cset_remove_elem	(	cset_hash_table_t *	hash_ptr,
		size_t	hashable_size,
		const void *	element,
		uint32_t	type_id
	)

Definition at line 385 of file sde_lib_datastructures.c.

                                                                                                              {
    cset_hash_bucket_t *bucket_ptr;
    int element_found = 0;
    uint32_t i, occupied;
    int ret_val;
 
    if( NULL == hash_ptr ){
        ret_val = SDE_EINVAL;
        goto fn_exit;
    }
    bucket_ptr = hash_ptr->buckets;
 
    uint64_t seed = (uint64_t)79365; // decided to be a good seed by a committee.
    uint64_t key = fasthash64(element, hashable_size, seed);
    int bucket_idx = (int)(key % _SDE_HASH_BUCKET_COUNT_);
    uint64_t *key_ptr = bucket_ptr[bucket_idx].keys;
    cset_hash_decorated_object_t *obj_ptr = bucket_ptr[bucket_idx].objects;
    occupied = bucket_ptr[bucket_idx].occupied;
    if( occupied > _SDE_HASH_BUCKET_WIDTH_ ){
        SDE_ERROR("cset_remove_elem(): Counting set is clobbered, bucket %d has exceeded capacity.",bucket_idx);
        ret_val = SDE_EINVAL;
        goto fn_exit;
    }
 
    // First look in the bucket where the hash function told us to look.
    for(i=0; i<occupied; i++){
        // If the key and type_id match a stored element and the hashable_size is less or equal to
        // the size of the stored element, then we are onto something.
        if( (key == key_ptr[i]) && (type_id == obj_ptr[i].type_id) && (hashable_size <= obj_ptr[i].type_size) ){
            // If the actual element matches too (or if we don't care about perfect matches),
            // then we update the count for this entry.
            if( SDE_HASH_IS_FUZZY || !memcmp(element, obj_ptr[i].ptr, hashable_size) ){
                obj_ptr[i].count -= 1;
                // If the element reached a count of zero after we removed it, then shift all the other keys and entries in the bucket.
                if( 0 == obj_ptr[i].count ){
                    uint32_t j;
                    // free the memory taken by the user object.
                    free(obj_ptr[i].ptr);
                    // now shift the remaining entries in this bucket.
                    for(j=i; j<occupied-1; j++){
                        key_ptr[j] = key_ptr[j+1];
                        obj_ptr[j] = obj_ptr[j+1];
                    }
                    bucket_ptr[bucket_idx].occupied -= 1;
                }
                // since we found the element, we don't need to look further.
                element_found = 1;
                break;
            }
        }
    }
 
    // If we didn't find the element in the appropriate bucket, then we need to look for it in the overflow list.
    if( !element_found ){
        // If the overflow list is empty, then something went wrong.
        if( NULL == hash_ptr->overflow_list ){
            SDE_ERROR("cset_remove_elem(): Attempted to remove element that is NOT in the counting set.");
        }else{
            // Since there are elements in the overflow list, we need to search there for the one we are looking for.
            cset_list_object_t *list_runner, *prev;
            prev = hash_ptr->overflow_list;
            for( list_runner = hash_ptr->overflow_list; list_runner != NULL; list_runner = list_runner->next){
                // if we find the element in the overflow list
                if( (hashable_size <= list_runner->type_size) && (type_id == list_runner->type_id) && !memcmp(element, list_runner->ptr, hashable_size) ){
                    list_runner->count -= 1;
                    // If the element reached a count of zero, then remove it from the list, and connect the list around it.
                    if( 0 == list_runner->count ){
                        // free the memory taken by the user object.
                        free(list_runner->ptr);
                        if( list_runner == hash_ptr->overflow_list ){
                            hash_ptr->overflow_list = NULL;
                        }else{
                            prev->next = list_runner->next;
                        }
                        // free the memory taken by the link node. We can do this here safely
                        // because we will break out of the loop, so we will not need the "next" pointer.
                        free(list_runner);
                    }
                    // since we found the element, we don't need to look at the rest of the list.
                    break;
                }
                prev = list_runner;
            }
        }
    }
 
    ret_val = SDE_OK;
fn_exit:
    return ret_val;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cset_to_list()

cset_list_object_t * cset_to_list

(

cset_hash_table_t *

hash_ptr

)

Definition at line 476 of file sde_lib_datastructures.c.

                                                             {
    cset_hash_bucket_t *bucket_ptr;
    int bucket_idx;
    uint32_t i, occupied;
    cset_list_object_t *head_ptr = NULL;
 
    if( NULL == hash_ptr ){
        return NULL;
    }
    bucket_ptr = hash_ptr->buckets;
 
    for( bucket_idx = 0; bucket_idx < _SDE_HASH_BUCKET_COUNT_; bucket_idx++){
        cset_hash_decorated_object_t *obj_ptr = bucket_ptr[bucket_idx].objects;
        occupied = bucket_ptr[bucket_idx].occupied;
 
        for(i=0; i<occupied; i++){
            int type_size = obj_ptr[i].type_size;
            cset_list_object_t *new_list_element = (cset_list_object_t *)malloc(sizeof(cset_list_object_t));
            // make the current list head be the element after the new one we are creating.
            new_list_element->next = head_ptr;
            new_list_element->count = obj_ptr[i].count;
            new_list_element->type_id = obj_ptr[i].type_id;
            new_list_element->type_size = type_size;
            new_list_element->ptr = malloc(type_size);
            (void)memcpy(new_list_element->ptr, obj_ptr[i].ptr, type_size);
            // Update the head of the list to point to the new element.
            head_ptr = new_list_element;
        }
     }
 
    cset_list_object_t *list_runner;
    // Since there are elements in the overflow list, we need to search for ours.
    for( list_runner = hash_ptr->overflow_list; list_runner != NULL; list_runner = list_runner->next){
        int type_size = list_runner->type_size;
        cset_list_object_t *new_list_element = (cset_list_object_t *)malloc(sizeof(cset_list_object_t));
        // make the current list head be the element after the new one we are creating.
        new_list_element->next = head_ptr;
        new_list_element->count = list_runner->count;
        new_list_element->type_id = list_runner->type_id;
        new_list_element->type_size = type_size;
        new_list_element->ptr = malloc(type_size);
        (void)memcpy(new_list_element->ptr, list_runner->ptr, type_size);
        // Update the head of the list to point to the new element.
        head_ptr = new_list_element;
    }
 
    return head_ptr;
}

Here is the caller graph for this function:

do_sde_init()

papi_handle_t do_sde_init	(	const char *	name_of_library,
		papisde_control_t *	gctl
	)

Definition at line 91 of file sde_lib_misc.c.

                                                                               {
 
    papisde_library_desc_t *tmp_lib;
 
    SDEDBG("Registering library: '%s'\n",name_of_library);
 
    // If the library is already initialized, return the handle to it
    tmp_lib = find_library_by_name(name_of_library, gctl);
    if( NULL != tmp_lib ){
        return tmp_lib;
    }
 
    // If the library is not already initialized, then initialize it.
    tmp_lib = ( papisde_library_desc_t* ) calloc( 1, sizeof( papisde_library_desc_t ) );
    tmp_lib->libraryName = strdup(name_of_library);
 
    insert_library_handle(tmp_lib, gctl);
 
    return tmp_lib;
}

Here is the call graph for this function:

Here is the caller graph for this function:

exp_container_init()

void exp_container_init	(	sde_counter_t *	handle,
		size_t	typesize
	)

exp_container_insert_element()

int exp_container_insert_element	(	recorder_data_t *	exp_container,
		size_t	typesize,
		const void *	value
	)

Definition at line 229 of file sde_lib_datastructures.c.

                                                                                                    {
    long long used_entries, total_entries, prev_entries, offset;
    int i, chunk;
    long long tmp_size;
 
    if( NULL == exp_container || NULL == exp_container->ptr_array[0]){
        SDE_ERROR("exp_container_insert_element(): Exponential container is clobbered. Unable to insert element.");
        return SDE_EINVAL;
    }
 
    used_entries = exp_container->used_entries;
    total_entries = exp_container->total_entries;
    assert(used_entries <= total_entries);
 
    // Find how many chunks we have already allocated
    tmp_size = 0;
    for(i=0; i<EXP_CONTAINER_ENTRIES; i++){
       long long factor = (long long)1<<i; // 2^i;
       prev_entries = tmp_size;
       tmp_size += factor * EXP_CONTAINER_MIN_SIZE;
       // At least the first chunk "exp_container->ptr_array[0]"
       // must have been already allocated when creating the recorder, so we can
       // compare the total size after we add the "i-th" size.
       if (total_entries == tmp_size)
           break;
    }
    chunk = i;
 
    // Find how many entries down the last chunk we are.
    offset = used_entries - prev_entries;
 
    if( used_entries == total_entries ){
        long long new_segment_size;
 
        // If we had used all the available entries (and thus we are allocating more), we start from the beginning of the new chunk.
        offset = 0;
 
        chunk += 1; // we need to allocate the next chunk from the last one we found.
        new_segment_size = ((long long)1<<chunk) * EXP_CONTAINER_MIN_SIZE;
        exp_container->ptr_array[chunk] = malloc(new_segment_size*typesize);
        exp_container->total_entries += new_segment_size;
    }
 
    void *dest = (char *)(exp_container->ptr_array[chunk]) + offset*typesize;
 
    (void)memcpy( dest, value, typesize );
    exp_container->used_entries++;
 
    return SDE_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

exp_container_to_contiguous()

void exp_container_to_contiguous	(	recorder_data_t *	exp_container,
		void *	cont_buffer
	)

Definition at line 204 of file sde_lib_datastructures.c.

                                                                                   {
    long long current_size, typesize, used_entries, tmp_size = 0;
    void *src, *dst;
    int i;
 
    typesize = exp_container->typesize;
    used_entries = exp_container->used_entries;
 
    for(i=0; i<EXP_CONTAINER_ENTRIES; i++){
       current_size = ((long long)1<<i) * EXP_CONTAINER_MIN_SIZE;
       src = exp_container->ptr_array[i];
       dst = (char *)cont_buffer + tmp_size*typesize;
       if ( (tmp_size+current_size) <= used_entries){
           memcpy(dst, src, current_size*typesize);
           if ( (tmp_size+current_size) == used_entries){
               return;
           }
       }else{
           memcpy(dst, src, (used_entries-tmp_size)*typesize);
           return;
       }
       tmp_size += current_size;
    }
}

Here is the caller graph for this function:

fasthash64()

static uint64_t fasthash64 ( const void *  buf, size_t  len, uint64_t  seed  )

inlinestatic

Definition at line 245 of file sde_lib_internal.h.

{
    const uint64_t    m = 0x880355f21e6d1965ULL;
    const uint64_t *pos = (const uint64_t *)buf;
    const uint64_t *end = pos + (len / 8);
    const uint32_t *pos2;
    uint64_t h = seed ^ (len * m);
    uint64_t v;
 
    while (pos != end) {
        v  = *pos++;
        h ^= mix(v);
        h *= m;
    }
 
    pos2 = (const uint32_t*)pos;
    v = 0;
 
    switch (len & 7) {
    case 7: v ^= (uint64_t)pos2[6] << 48;
            /* fall through */
    case 6: v ^= (uint64_t)pos2[5] << 40;
            /* fall through */
    case 5: v ^= (uint64_t)pos2[4] << 32;
            /* fall through */
    case 4: v ^= (uint64_t)pos2[3] << 24;
            /* fall through */
    case 3: v ^= (uint64_t)pos2[2] << 16;
            /* fall through */
    case 2: v ^= (uint64_t)pos2[1] << 8;
            /* fall through */
    case 1: v ^= (uint64_t)pos2[0];
        h ^= mix(v);
        h *= m;
    }
 
    return mix(h);
}

Here is the caller graph for this function:

ht_delete()

sde_counter_t * ht_delete	(	papisde_list_entry_t *	hash_table,
		int	ht_key,
		uint32_t	uniq_id
	)

Definition at line 114 of file sde_lib_datastructures.c.

{
    papisde_list_entry_t *list_head, *curr, *prev;
    sde_counter_t *item;
 
    list_head = &hash_table[ht_key];
    if( NULL == list_head->item ){
        SDE_ERROR("ht_delete(): the entry does not exist.");
        return NULL;
    }
 
    // If the head contains the element to be deleted, free the space of the counter and pull the list up.
    if( list_head->item->glb_uniq_id == uniq_id ){
        item = list_head->item;
        if( NULL != list_head->next){
            *list_head = *(list_head->next);
        }else{
            memset(list_head, 0, sizeof(papisde_list_entry_t));
        }
        return item;
    }
 
    prev = list_head;
    // Traverse the linked list to find the element.
    for(curr=list_head->next; NULL != curr; curr=curr->next){
        if(NULL == curr->item){ // This is only permitted for the head of the list.
            SDE_ERROR("ht_delete(): the hash table is clobbered.");
            return NULL;
        }
        if(curr->item->glb_uniq_id == uniq_id){
            prev->next = curr->next;
            item = curr->item;
            free(curr); // free the hash table entry
            return item;
        }
        prev = curr;
    }
 
    SDE_ERROR("ht_delete(): the item is not in the list.");
    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ht_hash_id()

uint32_t ht_hash_id

(

uint32_t

uniq_id

)

Definition at line 18 of file sde_lib_datastructures.c.

                                     {
    return uniq_id%PAPISDE_HT_SIZE;
}

Here is the caller graph for this function:

ht_hash_name()

uint32_t ht_hash_name

(

const char *

str

)

Definition at line 23 of file sde_lib_datastructures.c.

{
    uint32_t hash = 5381;
    int c;
 
    while ((c = *str++))
        hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
 
    return hash % PAPISDE_HT_SIZE;
}

Here is the caller graph for this function:

ht_insert()

void ht_insert	(	papisde_list_entry_t *	hash_table,
		int	ht_key,
		sde_counter_t *	sde_counter
	)

Definition at line 34 of file sde_lib_datastructures.c.

{
    papisde_list_entry_t *list_head, *new_entry;
 
    list_head = &hash_table[ht_key];
    // If we have no counter is associated with this key we will put the new
    // counter on the head of the list which has already been allocated.
    if( NULL == list_head->item ){
        list_head->item = sde_counter;
        list_head->next = NULL; // Just for aesthetic reasons.
        return;
    }
 
    // If we made it here it means that the head was occupied, so we
    // will allocate a new element and put it just after the head.
    new_entry = (papisde_list_entry_t *)calloc(1, sizeof(papisde_list_entry_t));
    new_entry->item = sde_counter;
    new_entry->next = list_head->next;
    list_head->next = new_entry;
 
    return;
}

Here is the caller graph for this function:

ht_lookup_by_id()

sde_counter_t * ht_lookup_by_id	(	papisde_list_entry_t *	hash_table,
		uint32_t	uniq_id
	)

Definition at line 178 of file sde_lib_datastructures.c.

{
    papisde_list_entry_t *list_head, *curr;
 
    list_head = &hash_table[ht_hash_id(uniq_id)];
    if( NULL == list_head->item ){
        return NULL;
    }
 
    for(curr=list_head; NULL != curr; curr=curr->next){
        if(NULL == curr->item){ // This can only legally happen for the head of the list.
            SDE_ERROR("ht_lookup_by_id() the hash table is clobbered.");
            return NULL;
        }
        if(curr->item->glb_uniq_id == uniq_id){
            return curr->item;
        }
    }
 
    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ht_lookup_by_name()

sde_counter_t * ht_lookup_by_name	(	papisde_list_entry_t *	hash_table,
		const char *	name
	)

Definition at line 156 of file sde_lib_datastructures.c.

{
    papisde_list_entry_t *list_head, *curr;
 
    list_head = &hash_table[ht_hash_name(name)];
    if( NULL == list_head->item ){
        return NULL;
    }
 
    for(curr=list_head; NULL != curr; curr=curr->next){
        if(NULL == curr->item){ // This can only legally happen for the head of the list.
            SDE_ERROR("ht_lookup_by_name() the hash table is clobbered.");
            return NULL;
        }
        if( !strcmp(curr->item->name, name) ){
            return curr->item;
        }
    }
 
    return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ht_to_array()

int ht_to_array	(	papisde_list_entry_t *	hash_table,
		sde_counter_t **	rslt_array
	)

Definition at line 65 of file sde_lib_datastructures.c.

{
    int i, item_cnt = 0, index=0;
    papisde_list_entry_t *list_head, *curr;
 
    // First pass counts how many items have been inserted in the hash table.
 
    // Traverse all the elements of the hash-table.
    for(i=0; i<PAPISDE_HT_SIZE; i++){
        // For each element traverse the linked-list starting there (if any).
        list_head = &(hash_table[i]);
 
        if(NULL != list_head->item){
            item_cnt++;
        }
        for(curr = list_head->next; NULL != curr; curr=curr->next){
            if(NULL == curr->item){ // This can only legally happen for the head of the list.
                SDE_ERROR("ht_to_array(): the hash table is clobbered.");
            }else{
                item_cnt++;
            }
        }
    }
 
    // Allocate a contiguous array to store the items.
    sde_counter_t *array = (sde_counter_t *)malloc( item_cnt * sizeof(sde_counter_t));
 
    // Traverse the hash-table again and copy all the items to the array we just allocated.
    for(i=0; i<PAPISDE_HT_SIZE; i++){
        list_head = &(hash_table[i]);
 
        if(NULL != list_head->item){
            memcpy( &array[index], list_head->item, sizeof(sde_counter_t) );
            index++;
        }
        for(curr = list_head->next; NULL != curr; curr=curr->next){
            if(NULL == curr->item){ // This can only legally happen for the head of the list.
                SDE_ERROR("ht_to_array(): the hash table is clobbered.");
            }else{
                memcpy( &array[index], curr->item, sizeof(sde_counter_t) );
                index++;
            }
        }
    }
    *rslt_array = array;
 
    return item_cnt;
}

Here is the call graph for this function:

Here is the caller graph for this function:

papi_sde_counting_set_to_list()

void papi_sde_counting_set_to_list	(	void *	cset_handle,
		cset_list_object_t **	list_head
	)

sde_ti_get_event_description()

char * sde_ti_get_event_description

(

int

event_id

)

Definition at line 416 of file sde_lib_ti.c.

                                          {
 
    papisde_control_t *gctl = _papisde_global_control;
    if( NULL == gctl )
        return NULL;
 
    sde_counter_t *counter = ht_lookup_by_id(gctl->all_reg_counters, event_id);
    if( NULL == counter )
        return NULL;
 
    return counter->description;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sde_ti_get_event_name()

char * sde_ti_get_event_name

(

int

event_id

)

Definition at line 399 of file sde_lib_ti.c.

                                   {
 
    papisde_control_t *gctl = _papisde_global_control;
    if( NULL == gctl )
        return NULL;
 
    sde_counter_t *counter = ht_lookup_by_id(gctl->all_reg_counters, event_id);
    if( NULL == counter )
        return NULL;
 
    return counter->name;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sde_ti_get_num_reg_events()

int sde_ti_get_num_reg_events

(

void

)

Definition at line 433 of file sde_lib_ti.c.

                                 {
 
    papisde_control_t *gctl = _papisde_global_control;
    if( NULL == gctl )
        return 0;
 
    return gctl->num_reg_events;
}

Here is the caller graph for this function:

sde_ti_is_counter_set_to_overflow()

int sde_ti_is_counter_set_to_overflow

(

uint32_t

counter_id

)

Definition at line 343 of file sde_lib_ti.c.

                                                      {
 
    papisde_control_t *gctl = _papisde_global_control;
    if( NULL == gctl )
        return 0;
 
    sde_counter_t *counter = ht_lookup_by_id(gctl->all_reg_counters, counter_id);
    if( (NULL == counter) || !counter->overflow || IS_CNTR_CREATED(counter) )
        return 0;
 
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sde_ti_is_simple_counter()

int sde_ti_is_simple_counter

(

uint32_t

counter_id

)

Definition at line 325 of file sde_lib_ti.c.

                                             {
 
    papisde_control_t *gctl = _papisde_global_control;
    if( NULL == gctl )
        return 0;
 
    sde_counter_t *counter = ht_lookup_by_id(gctl->all_reg_counters, counter_id);
 
    if( (NULL == counter) || !IS_CNTR_REGISTERED(counter) )
        return 0;
 
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sde_ti_name_to_code()

int sde_ti_name_to_code	(	const char *	event_name,
		uint32_t *	event_code
	)

Definition at line 204 of file sde_lib_ti.c.

                                                                  {
    int ret_val;
    papisde_library_desc_t *lib_handle;
    char *pos, *tmp_lib_name;
    sde_counter_t *tmp_item = NULL;
    papisde_control_t *gctl;
 
    SDEDBG( "%s\n", event_name );
 
    sde_lock();
    gctl = _papisde_global_control;
 
    // Let's see if the event has the library name as a prefix (as it should). Note that this is
    // the event name as it comes from the framework, so it should contain the library name, although
    // when the library registers an event counter it will not use the library name as part of the event name.
    tmp_lib_name = strdup(event_name);
    pos = strstr(tmp_lib_name, "::");
    if( NULL != pos ){ // Good, it does.
        *pos = '\0';
 
        if( NULL == gctl ){
            // If no library has initialized SDEs, and the application is already inquiring
            // about an event, let's initialize SDEs pretending to be the library which corresponds to this event.
            gctl = sdei_get_global_struct();
            lib_handle = do_sde_init(tmp_lib_name, gctl);
            if(NULL == lib_handle){
                SDE_ERROR("sde_ti_name_to_code(): Initialized SDE but unable to register new library: %s\n", tmp_lib_name);
                ret_val = SDE_ECMP;
                goto fn_exit;
            }
        }else{
            int is_library_present = 0;
            // If the library side of the component has been initialized, then look for the library.
            lib_handle = gctl->lib_list_head;
            while(NULL != lib_handle){ // Look for the library.
                if( !strcmp(lib_handle->libraryName, tmp_lib_name) ){
                    // We found the library.
                    is_library_present = 1;
                    // Now, look for the event in the library.
                    tmp_item = ht_lookup_by_name(lib_handle->lib_counters, event_name);
                    break;
                }
                lib_handle = lib_handle->next;
            }
 
            if( !is_library_present ){
                // If the library side of the component was initialized, but the specific library hasn't called
                // papi_sde_init() then we call it here to allocate the data structures.
                lib_handle = do_sde_init(tmp_lib_name, gctl);
                if(NULL == lib_handle){
                    SDE_ERROR("sde_ti_name_to_code(): Unable to register new library: %s\n", tmp_lib_name);
                    ret_val = SDE_ECMP;
                    goto fn_exit;
                }
             }
        }
        free(tmp_lib_name); // We don't need the library name any more.
 
        if( NULL != tmp_item ){
            SDEDBG("Found matching counter with global uniq id: %d in library: %s\n", tmp_item->glb_uniq_id, lib_handle->libraryName );
            *event_code = tmp_item->glb_uniq_id;
            ret_val = SDE_OK;
            goto fn_exit;
        } else {
            cntr_class_specific_t cntr_union = {0};
            SDEDBG("Did not find event %s in library %s. Registering a placeholder.\n", event_name, lib_handle->libraryName );
 
            // Use the current number of registered events as the index of the new one, and increment it.
            uint32_t counter_uniq_id = gctl->num_reg_events++;
            gctl->num_live_events++;
 
            // At this point in the code "lib_handle" contains a pointer to the data structure for this library whether
            // the actual library has been initialized or not.
            tmp_item = allocate_and_insert(gctl, lib_handle, event_name, counter_uniq_id, PAPI_SDE_RO, PAPI_SDE_long_long, CNTR_CLASS_PLACEHOLDER, cntr_union );
            if(NULL == tmp_item) {
                SDEDBG("Event %s does not exist in library %s and placeholder could not be inserted.\n", event_name, lib_handle->libraryName);
                ret_val = SDE_ECMP;
                goto fn_exit;
            }
            *event_code = tmp_item->glb_uniq_id;
            ret_val = SDE_OK;
            goto fn_exit;
        }
    }else{
        free(tmp_lib_name);
    }
 
    // If no library has initialized the component and we don't know a library name, then we have to return.
    if( NULL == gctl ){
        ret_val = SDE_ENOEVNT;
        goto fn_exit;
    }
 
    // If the event name does not have the library name as a prefix, then we need to look in all the libraries for the event. However, in this case
    // we can _not_ register a placeholder because we don't know which library the event belongs to.
    lib_handle = gctl->lib_list_head;
    while(NULL != lib_handle){
 
        tmp_item = ht_lookup_by_name(lib_handle->lib_counters, event_name);
        if( NULL != tmp_item ){
            *event_code = tmp_item->glb_uniq_id;
            SDEDBG("Found matching counter with global uniq id: %d in library: %s\n", tmp_item->glb_uniq_id, lib_handle->libraryName );
            ret_val = SDE_OK;
            goto fn_exit;
        } else {
            SDEDBG("Failed to find event %s in library %s. Looking in other libraries.\n", event_name, lib_handle->libraryName );
        }
 
        lib_handle = lib_handle->next;
    }
 
    ret_val = SDE_ENOEVNT;
fn_exit:
    sde_unlock();
    return ret_val;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sde_ti_read_counter()

int sde_ti_read_counter	(	uint32_t	,
		long long int *
	)

Here is the caller graph for this function:

sde_ti_reset_counter()

int sde_ti_reset_counter

(

uint32_t

counter_id

)

Definition at line 169 of file sde_lib_ti.c.

                                           {
    int ret_val = SDE_OK;
    papisde_control_t *gctl;
 
    gctl = _papisde_global_control;
    if( NULL == gctl ){
        SDE_ERROR("sde_ti_reset_counter(): Attempt to modify unintialized SDE structures.\n");
        return SDE_EINVAL;
    }
 
    if( counter_id >= gctl->num_reg_events ){
        SDE_ERROR("sde_ti_reset_counter(): SDE with id %d does not correspond to a registered event.\n",counter_id);
        return SDE_EINVAL;
    }
 
    sde_counter_t *counter = ht_lookup_by_id(gctl->all_reg_counters, counter_id);
    if( (NULL == counter) || (!IS_CNTR_BASIC(counter) && !IS_CNTR_CALLBACK(counter)) ){
        SDEDBG("sde_ti_reset_counter(): SDE with id %d is clobbered, or a type which does not support resetting.\n",counter_id);
        // We allow tools to call this function even if the counter type does not support
        // reseting, so we do not return an error if this is the case.
        return SDE_OK;
    }
 
    ret_val = sdei_read_and_update_data_value( counter, 0, &(counter->previous_data) );
    if( SDE_OK != ret_val ){
        SDE_ERROR("sde_ti_reset_counter(): Error occured when resetting counter: %s.\n",counter->name);
    }
 
    return ret_val;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sde_ti_set_counter_overflow()

int sde_ti_set_counter_overflow	(	uint32_t	counter_id,
		int	threshold
	)

Definition at line 360 of file sde_lib_ti.c.

                                                               {
 
    papisde_control_t *gctl = _papisde_global_control;
    if( NULL == gctl )
        return SDE_OK;
 
    sde_counter_t *counter = ht_lookup_by_id(gctl->all_reg_counters, counter_id);
    // If the counter is created then we will check for overflow every time its value gets updated, we don't need to poll.
    // That is in cases c[1-3]
    if( IS_CNTR_CREATED(counter) )
        return SDE_OK;
 
    // We do not want to overflow on recorders or counting-sets, because we don't even know what this means.
    if( ( IS_CNTR_RECORDER(counter) || IS_CNTR_CSET(counter) ) && (threshold > 0) ){
        return SDE_EINVAL;
    }
 
    // If we still don't know what type the counter is, then we are _not_ in r[1-3] so we can't create a timer here.
    if( IS_CNTR_PLACEHOLDER(counter) && (threshold > 0) ){
        SDEDBG("Event is a placeholder (it has not been registered by a library yet), so we cannot start overflow, but we can remember it.\n");
        counter->overflow = 1;
        return SDE_OK;
    }
 
    if( 0 == threshold ){
        counter->overflow = 0;
    }
 
    // Return a number higher than SDE_OK (which is zero) to indicate to the caller that the timer needs to be set,
    // because SDE_OK only means that there was no error, but the timer should not be set either because we are dealing
    // with a placeholder, or created counter.
    return 0xFF;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sde_ti_shutdown()

int sde_ti_shutdown

(

void

)

Definition at line 446 of file sde_lib_ti.c.

                       {
    return SDE_OK;
}

Here is the caller graph for this function:

sde_ti_write_counter()

int sde_ti_write_counter	(	uint32_t	counter_id,
		long long	value
	)

Definition at line 136 of file sde_lib_ti.c.

                                                            {
    papisde_control_t *gctl;
    int ret_val = SDE_OK;
 
    gctl = _papisde_global_control;
    if( NULL == gctl ){
        SDE_ERROR("sde_ti_write_counter(): Attempt to write in unintialized SDE structures.\n");
        return SDE_EINVAL;
    }
 
    if( counter_id >= gctl->num_reg_events ){
        SDE_ERROR("sde_ti_write_counter(): SDE with id %d does not correspond to a registered event.\n",counter_id);
        return SDE_EINVAL;
    }
 
    sde_counter_t *counter = ht_lookup_by_id(gctl->all_reg_counters, counter_id);
    if( (NULL == counter) || !IS_CNTR_BASIC(counter) ){
        SDE_ERROR("sde_ti_write_counter(): SDE with id %d is clobbered, or a type which does not support writing.\n",counter_id);
        return SDE_EINVAL;
    }
 
    ret_val = sdei_hardware_write( counter, value );
    if( SDE_OK != ret_val ){
        SDE_ERROR("sde_ti_write_counter(): Error occured when writing counter: '%s'.\n",counter->name);
    }
 
    return ret_val;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sdei_counting_set_to_list()

void sdei_counting_set_to_list	(	void *	cset_handle,
		cset_list_object_t **	list_head
	)

Definition at line 135 of file sde_lib_misc.c.

{
    sde_counter_t *tmp_cset;
 
    if( NULL == list_head )
        return;
 
    tmp_cset = (sde_counter_t *)cset_handle;
    if( (NULL == tmp_cset) || !IS_CNTR_CSET(tmp_cset) || (NULL == tmp_cset->u.cntr_cset.data) ){
        SDE_ERROR("sdei_counting_set_to_list(): 'cset_handle' is clobbered.");
        return;
    }
 
    *list_head = cset_to_list(tmp_cset->u.cntr_cset.data);
 
    return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sdei_delete_counter()

int sdei_delete_counter	(	papisde_library_desc_t *	lib_handle,
		const char *	name
	)

Definition at line 260 of file sde_lib_misc.c.

                                                                              {
    sde_counter_t *tmp_item;
    papisde_control_t *gctl;
    uint32_t item_uniq_id;
    int ret_val = SDE_OK;
 
    gctl = sdei_get_global_struct();
 
    // Look for the counter entry in the hash-table of the library
    tmp_item = ht_lookup_by_name(lib_handle->lib_counters, name);
    if( NULL == tmp_item ){
        ret_val = SDE_EINVAL;
        goto fn_exit;
    }
 
    if( CNTR_CLASS_GROUP == tmp_item->cntr_class ){
        papisde_list_entry_t *curr, *prev;
        // If we are dealing with a goup, then we need to recurse down all its children and
        // delete them (this might mean free them, or just decrement their ref_count).
        curr = tmp_item->u.cntr_group.group_head;
        prev = curr;
        while(NULL != curr){
            int counter_is_dead = 0;
            sde_counter_t *tmp_cntr = curr->item;
            if( NULL == tmp_cntr ){
                ret_val = SDE_EMISC;
                goto fn_exit;
            }
 
            // If this counter is going to be freed, we need to remove it from this group.
            if( 0 == tmp_cntr->ref_count )
                counter_is_dead = 1;
 
            // recursively delete all the elements of the group.
            int ret_val = sdei_delete_counter(lib_handle, tmp_cntr->name);
            if( SDE_OK != ret_val )
                goto fn_exit;
 
            if( counter_is_dead ){
                if( curr == tmp_item->u.cntr_group.group_head ){
                    // if we were removing with the head, change the head, we can't free() it.
                    tmp_item->u.cntr_group.group_head = curr->next;
                    prev = curr->next;
                    curr = curr->next;
                }else{
                    // if we are removing an element, first bridge the previous to the next.
                    prev->next = curr->next;
                    free(curr);
                    curr = prev->next;
                }
            }else{
                // if we are not removing anything, just move the pointers.
                prev = curr;
                curr = curr->next;
            }
        }
    }
 
    item_uniq_id = tmp_item->glb_uniq_id;
 
    // If the reference count is not zero, then we don't remove it from the hash tables
    if( 0 == tmp_item->ref_count ){
        // Delete the entry from the library hash-table (which hashes by name)
        tmp_item = ht_delete(lib_handle->lib_counters, ht_hash_name(name), item_uniq_id);
        if( NULL == tmp_item ){
            ret_val = SDE_EMISC;
            goto fn_exit;
        }
 
        // Delete the entry from the global hash-table (which hashes by id) and free the memory
        // occupied by the counter (not the hash-table entry 'papisde_list_entry_t', the 'sde_counter_t')
        tmp_item = ht_delete(gctl->all_reg_counters, ht_hash_id(item_uniq_id), item_uniq_id);
        if( NULL == tmp_item ){
            ret_val = SDE_EMISC;
            goto fn_exit;
        }
 
        // We free the counter only once, although it is in two hash-tables,
        // because it is the same structure that is pointed to by both hash-tables.
        free_counter_resources(tmp_item);
 
        // Decrement the number of live events.
        (gctl->num_live_events)--;
    }else{
        (tmp_item->ref_count)--;
    }
 
fn_exit:
    return ret_val;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sdei_get_global_struct()

papisde_control_t * sdei_get_global_struct

(

void

)

sdei_get_global_struct() checks if the global structure has been allocated and allocates it if has not.

Returns

a pointer to the global structure.

Definition at line 34 of file sde_lib_misc.c.

                                               {
    // Allocate the global control structure, unless it has already been allocated by another library
    // or the application code calling PAPI_name_to_code() for an SDE.
    if ( !_papisde_global_control ) {
        SDEDBG("sdei_get_global_struct(): global SDE control struct is being allocated.\n");
        _papisde_global_control = (papisde_control_t *)calloc( 1, sizeof( papisde_control_t ) );
    }
    return _papisde_global_control;
}

Here is the caller graph for this function:

sdei_hardware_write()

int sdei_hardware_write	(	sde_counter_t *	counter,
		long long int	new_value
	)

Definition at line 556 of file sde_lib_misc.c.

                                                                      {
    double tmp_double;
    void *tmp_ptr;
 
    switch(counter->cntr_type){
        case PAPI_SDE_long_long:
            *((long long int *)(counter->u.cntr_basic.data)) = new_value;
            break;
        case PAPI_SDE_int:
            *((int *)(counter->u.cntr_basic.data)) = (int)new_value;
            break;
        case PAPI_SDE_double:
            tmp_ptr = &new_value;
            tmp_double = *((double *)tmp_ptr);
            *((double *)(counter->u.cntr_basic.data)) = tmp_double;
            break;
        case PAPI_SDE_float:
            // The pointer has to be 64bit. We can cast the variable to safely convert between bit-widths later on.
            tmp_ptr = &new_value;
            tmp_double = *((double *)tmp_ptr);
            *((float *)(counter->u.cntr_basic.data)) = (float)tmp_double;
            break;
        default:
            SDEDBG("Unsupported counter type: %d\n",counter->cntr_type);
            return -1;
    }
 
    return SDE_OK;
}

Here is the caller graph for this function:

sdei_inc_ref_count()

int sdei_inc_ref_count

(

sde_counter_t *

counter

)

Definition at line 236 of file sde_lib_misc.c.

                                              {
    papisde_list_entry_t *curr;
    if( NULL == counter )
        return SDE_OK;
 
    // If the counter is a group, recursivelly increment the ref_count of all its children.
    if(CNTR_CLASS_GROUP == counter->cntr_class){
        curr = counter->u.cntr_group.group_head;
        do{
            sde_counter_t *tmp_cntr = curr->item;
            // recursively increment the ref_count of all the elements in the group.
            int ret_val = sdei_inc_ref_count(tmp_cntr);
            if( SDE_OK != ret_val )
                return ret_val;
            curr = curr->next;
        }while(NULL != curr);
    }
 
    // Increment the ref_count of the counter itself, INCLUDING the case where the counter is a group.
    (counter->ref_count)++;
 
    return SDE_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sdei_read_and_update_data_value()

int sdei_read_and_update_data_value	(	sde_counter_t *	counter,
		long long int	previous_value,
		long long int *	rslt_ptr
	)

Definition at line 490 of file sde_lib_misc.c.

                                                                                                                 {
    int ret_val;
    long long int tmp_int;
    void *tmp_data;
 
    char *event_name = counter->name;
 
    if( IS_CNTR_BASIC(counter) ){
        SDEDBG("Reading %s by accessing data pointer.\n", event_name);
        tmp_data = counter->u.cntr_basic.data;
    }else if( IS_CNTR_CALLBACK(counter) ){
        SDEDBG("Reading %s by calling registered function pointer.\n", event_name);
        tmp_int = counter->u.cntr_cb.callback(counter->u.cntr_cb.param);
        tmp_data = &tmp_int;
    }else{
        SDEDBG("sdei_read_and_update_data_value(): Event %s has neither a variable nor a function pointer associated with it.\n", event_name);
        return -1;
    }
 
    if( is_instant(counter->cntr_mode) ){
        /* Instant counter means that we don't subtract the previous value (which we read at PAPI_Start()) */
        previous_value = 0;
    } else if( is_delta(counter->cntr_mode) ){
        /* Do nothing here, this is the default mode */
    } else{
        SDEDBG("Unsupported mode (%d) for event: %s\n",counter->cntr_mode, event_name);
        return -1;
    }
 
    ret_val = cast_and_store(tmp_data, previous_value, rslt_ptr, counter->cntr_type);
    return ret_val;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sdei_read_counter_group()

int sdei_read_counter_group	(	sde_counter_t *	counter,
		long long int *	rslt_ptr
	)

This function assumes that all counters in a group (including recursive subgroups) have the same type.

Definition at line 390 of file sde_lib_misc.c.

                                                                          {
    papisde_list_entry_t *curr;
    long long int final_value = 0;
 
    if( NULL == counter ){
        SDE_ERROR("sdei_read_counter_group(): Counter parameter is NULL.\n");
        return SDE_EINVAL;
    }
 
    if( !IS_CNTR_GROUP(counter) ){
        SDE_ERROR("sdei_read_counter_group(): Counter '%s' is not a counter group.\n",counter->name);
        return SDE_EINVAL;
    }
    curr = counter->u.cntr_group.group_head;
 
    do{
        long long int tmp_value = 0;
        int ret_val;
 
        sde_counter_t *tmp_cntr = curr->item;
        if( NULL == tmp_cntr ){
            SDE_ERROR("sdei_read_counter_group(): List of counters in counter group '%s' is clobbered.\n",counter->name);
            return SDE_EINVAL;
        }
 
        int read_succesfully = 1;
        // We can _not_ have a recorder inside a group.
        if( IS_CNTR_RECORDER(tmp_cntr) || IS_CNTR_CSET(tmp_cntr) || IS_CNTR_PLACEHOLDER(tmp_cntr) ){
            SDE_ERROR("sdei_read_counter_group(): Counter group contains counter: %s with class: %d.\n",tmp_cntr->name, tmp_cntr->cntr_class);
        }else{
            // We allow counter groups to contain other counter groups recursively.
            if( IS_CNTR_GROUP(tmp_cntr) ){
                ret_val = sdei_read_counter_group( tmp_cntr, &tmp_value );
                if( ret_val != SDE_OK ){
                    // If something went wrong with one counter group, ignore it silently.
                    read_succesfully = 0;
                }
            }else{ // If we are here it means that we are trying to read a real counter.
                ret_val = sdei_read_and_update_data_value( tmp_cntr, tmp_cntr->previous_data, &tmp_value );
                if( SDE_OK != ret_val ){
                    SDE_ERROR("sdei_read_counter_group(): Error occured when reading counter: %s.\n",tmp_cntr->name);
                    read_succesfully = 0;
                }
            }
 
            if( read_succesfully )
                aggregate_value_in_group(&tmp_value, &final_value, tmp_cntr->cntr_type, counter->u.cntr_group.group_flags);
        }
 
        curr = curr->next;
    }while(NULL != curr);
 
    *rslt_ptr = final_value;
    return SDE_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sdei_set_timer_for_overflow()

int sdei_set_timer_for_overflow ( void  )

inline

Definition at line 60 of file sde_lib.c.

                                 {
    if( NULL != papi_sde_set_timer_for_overflow_ptr )
        return (*papi_sde_set_timer_for_overflow_ptr)();
    return -1;
}

Here is the caller graph for this function:

sdei_setup_counter_internals()

int sdei_setup_counter_internals	(	papi_handle_t	handle,
		const char *	event_name,
		int	cntr_mode,
		int	cntr_type,
		enum CNTR_CLASS	cntr_class,
		cntr_class_specific_t	cntr_union
	)

Definition at line 156 of file sde_lib_misc.c.

{
    papisde_library_desc_t *lib_handle;
    sde_counter_t *tmp_item;
    uint32_t counter_uniq_id;
    char *full_event_name;
    int ret_val = SDE_OK;
    int needs_overflow = 0;
 
    lib_handle = (papisde_library_desc_t *) handle;
    if( (NULL == lib_handle) || (NULL == lib_handle->libraryName) ){
        SDE_ERROR("sdei_setup_counter_internals(): 'handle' is clobbered. Unable to register counter.");
        return SDE_EINVAL;
    }
 
    size_t str_len = strlen(lib_handle->libraryName)+strlen(event_name)+2+1; // +2 for "::" and +1 for '\0'
    full_event_name = (char *)malloc(str_len*sizeof(char));
    snprintf(full_event_name, str_len, "%s::%s", lib_handle->libraryName, event_name);
 
    SDEDBG("%s: Counter: '%s' will be added in library: %s.\n", __FILE__, full_event_name, lib_handle->libraryName);
 
    if( !is_instant(cntr_mode) && !is_delta(cntr_mode) ){
        SDE_ERROR("Unknown mode %d. SDE counter mode must be either Instant or Delta.",cntr_mode);
        free(full_event_name);
        return SDE_ECMP;
    }
 
    // Look if the event is already registered.
    tmp_item = ht_lookup_by_name(lib_handle->lib_counters, full_event_name);
 
    if( NULL != tmp_item ){
        if( !IS_CNTR_PLACEHOLDER(tmp_item) ){
            // If it is registered and it is _not_ a placeholder then ignore it silently.
            SDEDBG("%s: Counter: '%s' was already in library: %s.\n", __FILE__, full_event_name, lib_handle->libraryName);
            free(full_event_name);
            return SDE_OK;
        }
        // If we are here, then it IS a placeholder, so check if we need to start overflowing.
        if( tmp_item->overflow && ( (CNTR_CLASS_REGISTERED == cntr_class) || (CNTR_CLASS_CB == cntr_class) ) ){
            needs_overflow = 1;
        }
 
        // Since the counter is a placeholder update the mode, the type, and the union that contains the 'data'.
        SDEDBG("%s: Updating placeholder for counter: '%s' in library: %s.\n", __FILE__, full_event_name, lib_handle->libraryName);
 
        tmp_item->u = cntr_union;
        tmp_item->cntr_class = cntr_class;
        tmp_item->cntr_mode = cntr_mode;
        tmp_item->cntr_type = cntr_type;
        free(full_event_name);
 
        return SDE_OK;
    }
 
    // If neither the event, nor a placeholder exists, then use the current
    // number of registered events as the index of the new one, and increment it.
    papisde_control_t *gctl = sdei_get_global_struct();
    counter_uniq_id = gctl->num_reg_events++;
    gctl->num_live_events++;
 
    SDEDBG("%s: Counter %s has unique ID = %d\n", __FILE__, full_event_name, counter_uniq_id);
 
    tmp_item = allocate_and_insert( gctl, lib_handle, full_event_name, counter_uniq_id, cntr_mode, cntr_type, cntr_class, cntr_union );
 
    if(NULL == tmp_item) {
        SDEDBG("%s: Counter not inserted in SDE %s\n", __FILE__, lib_handle->libraryName);
        free(full_event_name);
        return SDE_ECMP;
    }
 
    free(full_event_name);
 
    // Check if we need to worry about overflow (cases r[4-6])
    if( needs_overflow ){
        ret_val = sdei_set_timer_for_overflow();
    }
 
    return ret_val;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

_papisde_global_control

papisde_control_t* _papisde_global_control

extern

This global variable is defined in sde_lib.c and points to the head of the control state list

This global variable points to the head of the control state list

Definition at line 37 of file sde_lib.c.