void vt_rusage_init()
{
uint32_t gid;
uint32_t i;
/* allocate vector of counter ids */
vt_rusage_cidv = (uint32_t*)calloc(ru_active_cntrn, sizeof(uint32_t));
if ( vt_rusage_cidv == NULL )
vt_error();
/* write counter group name definition */
gid = vt_def_counter_group(VT_CURRENT_THREAD, "Resources");
/* write counter definition for active counters */
for ( i = 0; i < ru_active_cntrn; i++ )
{
vt_rusage_cidv[i] =
vt_def_counter(VT_CURRENT_THREAD,
ru_active_cntrv[i]->name,
ru_active_cntrv[i]->unit,
ru_active_cntrv[i]->prop,
gid,
0);
}
}
/*
* Initialize Mutex, VampirTrace ids and registers the finalize function.
* This may be done implicitly by vt_cupti_count().
*/
void vt_cupti_init()
{
if(!vt_cupti_initialized){
#if (defined(VT_MT) || defined(VT_HYB))
VTThrd_createMutex(&VTThrdMutexCupti);
#endif
CUPTI_LOCK();
if(!vt_cupti_initialized){
vt_cntl_msg(2, "[CUPTI] Initializing ... ");
/* create VampirTrace counter group ID only once */
#if (defined(VT_MT) || defined(VT_HYB))
VTTHRD_LOCK_IDS();
#endif
rid_cupti_init = vt_def_region(VT_MASTER_THREAD, "vtcuptiHostThreadInit",
VT_NO_ID, VT_NO_LNO, VT_NO_LNO, "VT_CUPTI", VT_FUNCTION);
cgid_cupti = vt_def_counter_group(VT_MASTER_THREAD, "CUPTI");
#if (defined(VT_MT) || defined(VT_HYB))
VTTHRD_UNLOCK_IDS();
#endif
vt_cupti_capList = vt_cupti_setupMetricList();
/* register the finalize function of the CUDA wrapper to be called before
* the program exits and CUDA has done its implicit clean-up */
atexit(vt_cupti_finalize);
vt_cupti_initialized = 1;
CUPTI_UNLOCK();
}
}
}
void vt_memhook_init()
{
uint32_t fid;
uint32_t gid;
#if (defined(VT_MT) || defined(VT_HYB) || defined(VT_JAVA))
vt_error_msg("Memory tracing by GNU C malloc-hooks for threaded application "
"not yet supported");
#endif /* VT_MT || VT_HYB || VT_JAVA */
if( vt_memhook_is_initialized ) return;
vt_malloc_hook_org = __malloc_hook;
vt_realloc_hook_org = __realloc_hook;
vt_free_hook_org = __free_hook;
/* define source */
fid = vt_def_scl_file(VT_CURRENT_THREAD, "MEM");
/* define regions */
memhook_regid[MEMHOOK_REG_MALLOC] =
vt_def_region(VT_CURRENT_THREAD, "malloc", fid, VT_NO_LNO, VT_NO_LNO, NULL,
VT_MEMORY);
memhook_regid[MEMHOOK_REG_REALLOC] =
vt_def_region(VT_CURRENT_THREAD, "realloc", fid, VT_NO_LNO, VT_NO_LNO, NULL,
VT_MEMORY);
memhook_regid[MEMHOOK_REG_FREE] =
vt_def_region(VT_CURRENT_THREAD, "free", fid, VT_NO_LNO, VT_NO_LNO, NULL,
VT_MEMORY);
/* define markers, if necessary */
if( (memalloc_marker = vt_env_memtrace_marker()) )
{
memalloc_mid[MEMHOOK_MARK_ALLOC] =
vt_def_marker(VT_CURRENT_THREAD, "Memory Allocation", VT_MARKER_HINT);
memalloc_mid[MEMHOOK_MARK_FREE] =
vt_def_marker(VT_CURRENT_THREAD, "Memory Deallocation", VT_MARKER_HINT);
}
/* define counter group */
gid = vt_def_counter_group(VT_CURRENT_THREAD, "Memory");
/* define counter */
memalloc_cid =
vt_def_counter(VT_CURRENT_THREAD, "MEM_ALLOC",
VT_CNTR_ABS | VT_CNTR_NEXT,
gid, "Bytes");
vt_memhook_is_initialized = 1;
}
unsigned int VT_User_count_group_def__(const char* gname)
{
uint32_t gid;
VT_INIT;
VT_MEMHOOKS_OFF();
#if (defined(VT_MT) || defined(VT_HYB))
VTTHRD_LOCK_IDS();
#endif
gid = vt_def_counter_group(VT_CURRENT_THREAD, gname);
#if (defined(VT_MT) || defined(VT_HYB))
VTTHRD_UNLOCK_IDS();
#endif
VT_MEMHOOKS_ON();
return gid;
}
void vt_mallocwrap_init()
{
/* define memory related counter group */
mallocwrap_counter_group_id =
vt_def_counter_group(VT_CURRENT_THREAD, "Memory");
/* define memory allocation counter */
mallocwrap_counter_id =
vt_def_counter(VT_CURRENT_THREAD, "Memory Allocation", "Bytes",
VT_CNTR_ABS | VT_CNTR_NEXT, mallocwrap_counter_group_id, 0);
/* define memory (de)allocation markers, if desired
(env. VT_MEMTRACE_MARKER) */
if( (mallocwrap_write_markers = vt_env_memtrace_marker()) )
{
mallocwrap_marker_alloc_id =
vt_def_marker(VT_CURRENT_THREAD, "Memory Allocation", VT_MARKER_HINT);
mallocwrap_marker_free_id =
vt_def_marker(VT_CURRENT_THREAD, "Memory Deallocation", VT_MARKER_HINT);
}
}
/*
* Initialize VampirTrace IDs and registers the finalize function.
* This may be done implicitly by vt_cupti_count().
*/
void vt_cupti_events_init()
{
if(!vt_cuptievt_initialized){ /* fast check without lock */
vt_cupti_init();
VT_CUPTI_LOCK();
if(!vt_cuptievt_initialized){
vt_cntl_msg(2, "[CUPTI Events] Initializing ... ");
/* create VampirTrace counter group ID only once */
#if (defined(VT_MT) || defined(VT_HYB))
VTTHRD_LOCK_IDS();
#endif
vt_cuptievt_rid_init = vt_def_region(VT_MASTER_THREAD, "vtcuptiHostThreadInit",
VT_NO_ID, VT_NO_LNO, VT_NO_LNO, "VT_CUPTI", VT_FUNCTION);
vt_cuptievt_cgid = vt_def_counter_group(VT_MASTER_THREAD, "CUPTI");
#if (defined(VT_MT) || defined(VT_HYB))
VTTHRD_UNLOCK_IDS();
#endif
vt_cupti_events_sampling = (uint8_t)vt_env_cupti_sampling();
vtcuptievtCapList = vt_cuptievt_setupMetricList();
if(NULL == vtcuptievtCapList){
vt_cupti_events_enabled = 0;
}else{
/* register the finalize function of VampirTrace CUPTI to be called before
* the program exits */
atexit(vt_cupti_events_finalize);
}
vt_cuptievt_initialized = 1;
VT_CUPTI_UNLOCK();
}
}
}
void vt_plugin_cntr_init() {
char ** plugins;
int nr_selected_plugins = 0;
char * plugin_read_start;
int read_plugin;
char * current_plugin;
char * env_vt_plugin_metrics;
char current_plugin_metric[255];
char * next_plugin_metric;
char * env_vt_callback_buffer;
char buffer[512];
char * dl_lib_error;
void * handle;
vt_plugin_cntr_info info;
/* used union to get rid of compiler warning */
union {
void * vp;
vt_plugin_cntr_info (* function)(void);
} get_info;
int index;
int i;
int found = 0;
struct vt_plugin * current;
/* set some internal variables to zero */
vt_plugin_handles = calloc(VT_PLUGIN_CNTR_SYNCH_TYPE_MAX,
sizeof(struct vt_plugin *));
nr_plugins = calloc(VT_PLUGIN_CNTR_SYNCH_TYPE_MAX, sizeof(uint32_t));
/* check whether plugins are activated */
env_vt_plugin_metrics = getenv("VT_PLUGIN_CNTR_METRICS");
if (env_vt_plugin_metrics == NULL)
return;
env_vt_callback_buffer = getenv("VT_PLUGIN_CNTR_CALLBACK_BUFFER");
/* default: 1 M elements (16 MiB memory) per thread and callback counter */
if (env_vt_callback_buffer == NULL)
max_values_callback = 1024 * 1024;
else
max_values_callback = atoi(env_vt_callback_buffer);
/* extract the plugin names */
plugin_read_start = env_vt_plugin_metrics;
read_plugin = 1;
current_plugin = plugin_read_start;
plugins = NULL;
/* go through the plugin env. variable */
for (; *current_plugin != '\0'; current_plugin++) {
if (read_plugin) {
if (*current_plugin == '_') {
/* do not use the same plugin twice! */
memcpy(buffer, plugin_read_start,
((current_plugin - plugin_read_start)) * sizeof(char));
buffer[(current_plugin - plugin_read_start)] = '\0';
found = 0;
for (i = 0; i < nr_selected_plugins; i++) {
if (strcmp(buffer, plugins[i]) == 0)
found = 1;
}
if (found) {
read_plugin = 0;
continue;
} else {
nr_selected_plugins++;
/* allocate the plugin name buffer */
plugins = realloc(plugins, nr_selected_plugins * sizeof(char*));
plugins[nr_selected_plugins - 1] = malloc(
(current_plugin - plugin_read_start + 1) * sizeof(char));
/* copy the content to the buffer */
memcpy(plugins[nr_selected_plugins - 1], plugin_read_start,
((current_plugin - plugin_read_start)) * sizeof(char));
/* finish with null */
plugins[nr_selected_plugins - 1]
[(current_plugin - plugin_read_start)] = '\0';
read_plugin = 0;
}
}
} else {
/* a new plugin/counter starts after the ':' */
if (*current_plugin == ':') {
read_plugin = 1;
plugin_read_start = current_plugin + 1;
}
}
}
/*go through all plugins:*/
for (i = 0; i < nr_selected_plugins; i++) {
uint32_t group = 0;
current_plugin = plugins[i];
vt_cntl_msg(2, "Loading plugin counter library: lib%s.so", current_plugin);
/* next one is stored in next_plugin,
/ * current is stored in current_plugin_buffer */
/* load it from LD_LIBRARY_PATH*/
sprintf(buffer, "lib%s.so", current_plugin);
/* now dlopen it */
handle = dlopen(buffer, RTLD_NOW);
/* if it is not valid */
if ((dl_lib_error = dlerror()) != NULL) {
vt_error_msg("Error loading plugin: %s\n", dl_lib_error);
/* try loading next */
continue;
}
/* now get the info */
get_info.vp = dlsym(handle, "get_info");
if ((dl_lib_error = dlerror()) != NULL) {
vt_error_msg("Error getting info from plugin: %s\n", dl_lib_error);
dlclose(handle);
/* try loading next */
continue;
}
/* now store it */
/* get the info */
info = get_info.function();
/* check the run per type */
if (info.run_per == VT_PLUGIN_CNTR_PER_PROCESS) {
if (thread_group == INVALID_GROUP_NUMBER){
vt_cntl_msg(3, "No process group defined, using master thread for %s",
current_plugin);
}
else{
# if (defined(VT_MT) || defined(VT_HYB))
/* only called per process */
group = vt_get_curid();
thread_group = group;
# else
/* not multithreaded -> keep information on local process */
#endif
}
}
if (info.run_per == VT_PLUGIN_CNTR_PER_HOST) {
if (!vt_my_trace_is_master)
continue;
else if (host_group == INVALID_GROUP_NUMBER){
host_group = vt_node_pgid;
vt_def_procgrp_attributes(VT_MY_THREAD ,vt_node_pgid,
VT_PROCGRP_HASCOUNTERS);
}
group = host_group;
}
if (info.run_per == VT_PLUGIN_CNTR_ONCE) {
if (vt_my_trace != 0)
continue;
else if (all_group == INVALID_GROUP_NUMBER){
all_group = vt_all_pgid;
vt_def_procgrp_attributes(VT_MY_THREAD ,vt_all_pgid,
VT_PROCGRP_HASCOUNTERS);
}
group = all_group;
}
if (info.init == NULL) {
vt_error_msg(
"Init not implemented in plugin %s\n",
current_plugin);
/* try loading next */
continue;
}
if (info.add_counter == NULL) {
vt_error_msg(
"Add counter not implemented in plugin %s\n",
current_plugin);
/* try loading next */
continue;
}
if (info.get_event_info == NULL) {
vt_error_msg("Get event info not implemented in plugin %s\n",
current_plugin);
/* try loading next */
continue;
}
/* check the type of plugin */
switch (info.synch) {
case VT_PLUGIN_CNTR_SYNCH:
nr_plugins[VT_PLUGIN_CNTR_SYNCH]++;
vt_plugin_handles[VT_PLUGIN_CNTR_SYNCH] = realloc(
vt_plugin_handles[VT_PLUGIN_CNTR_SYNCH],
nr_plugins[VT_PLUGIN_CNTR_SYNCH] * sizeof(struct vt_plugin));
current
= &vt_plugin_handles[VT_PLUGIN_CNTR_SYNCH]
[nr_plugins[VT_PLUGIN_CNTR_SYNCH] - 1];
if (info.get_current_value == NULL) {
nr_plugins[VT_PLUGIN_CNTR_SYNCH]--;
vt_error_msg("Get current results not implemented in plugin %s\n",
current_plugin);
/* try loading next */
continue;
}
break;
case VT_PLUGIN_CNTR_ASYNCH_CALLBACK:
nr_plugins[VT_PLUGIN_CNTR_ASYNCH_CALLBACK]++;
vt_plugin_handles[VT_PLUGIN_CNTR_ASYNCH_CALLBACK]
= realloc(
vt_plugin_handles[VT_PLUGIN_CNTR_ASYNCH_CALLBACK],
nr_plugins[VT_PLUGIN_CNTR_ASYNCH_CALLBACK]
* sizeof(struct vt_plugin));
current
= &vt_plugin_handles[VT_PLUGIN_CNTR_ASYNCH_CALLBACK]
[nr_plugins[VT_PLUGIN_CNTR_ASYNCH_CALLBACK] - 1];
if (info.set_callback_function == NULL) {
nr_plugins[VT_PLUGIN_CNTR_ASYNCH_CALLBACK]--;
vt_error_msg("set callback not implemented in plugin %s\n",
current_plugin);
/* try loading next */
continue;
}
if (info.set_pform_wtime_function == NULL) {
nr_plugins[VT_PLUGIN_CNTR_ASYNCH_CALLBACK]--;
vt_error_msg(
"set wtime not implemented in plugin %s\n",
current_plugin);
/* try loading next */
continue;
}
break;
case VT_PLUGIN_CNTR_ASYNCH_EVENT:
nr_plugins[VT_PLUGIN_CNTR_ASYNCH_EVENT]++;
vt_plugin_handles[VT_PLUGIN_CNTR_ASYNCH_EVENT] = realloc(
vt_plugin_handles[VT_PLUGIN_CNTR_ASYNCH_EVENT],
nr_plugins[VT_PLUGIN_CNTR_ASYNCH_EVENT] * sizeof(struct vt_plugin));
current
= &vt_plugin_handles[VT_PLUGIN_CNTR_ASYNCH_EVENT]
[nr_plugins[VT_PLUGIN_CNTR_ASYNCH_EVENT] - 1];
if (info.get_all_values == NULL) {
nr_plugins[VT_PLUGIN_CNTR_ASYNCH_EVENT]--;
vt_error_msg("get all values not implemented in plugin %s\n",
current_plugin);
/* try loading next */
continue;
}
if (info.set_pform_wtime_function == NULL) {
nr_plugins[VT_PLUGIN_CNTR_ASYNCH_EVENT]--;
vt_error_msg(
"set wtime not implemented in plugin %s\n",
current_plugin);
/* try loading next */
continue;
}
break;
case VT_PLUGIN_CNTR_ASYNCH_POST_MORTEM:
nr_plugins[VT_PLUGIN_CNTR_ASYNCH_POST_MORTEM]++;
vt_plugin_handles[VT_PLUGIN_CNTR_ASYNCH_POST_MORTEM] = realloc(
vt_plugin_handles[VT_PLUGIN_CNTR_ASYNCH_POST_MORTEM],
nr_plugins[VT_PLUGIN_CNTR_ASYNCH_POST_MORTEM]
* sizeof(struct vt_plugin));
current
= &vt_plugin_handles[VT_PLUGIN_CNTR_ASYNCH_POST_MORTEM]
[nr_plugins[VT_PLUGIN_CNTR_ASYNCH_POST_MORTEM] - 1];
if (info.get_all_values == NULL) {
vt_error_msg("get all values not implemented in plugin %s\n",
current_plugin);
nr_plugins[VT_PLUGIN_CNTR_ASYNCH_POST_MORTEM]--;
/* try loading next */
continue;
}
if (info.set_pform_wtime_function == NULL) {
vt_error_msg(
"set wtime not implemented in plugin %s\n",
current_plugin);
nr_plugins[VT_PLUGIN_CNTR_ASYNCH_POST_MORTEM]--;
/* try loading next */
continue;
}
break;
default:
vt_error_msg(
"Error getting synch type from plugin (invalid synch type)\n");
continue;
}
/* clear out current plugin */
memset(current, 0, sizeof(struct vt_plugin));
/* add handle (should be closed in the end) */
current->dlfcn_handle = handle;
/* store the info object of the plugin */
current->info = info;
/* store the name of the plugin */
current->name = current_plugin;
/* give plugin the wtime function to make it possible to convert times */
if (current->info.set_pform_wtime_function != NULL) {
current->info.set_pform_wtime_function(vt_pform_wtime);
}
vt_cntl_msg(3, "Initializing plugin counter library: lib%s.so",
current_plugin);
/* initialize plugin */
if (current->info.init()) {
vt_error_msg("Error initializing plugin %s, init returned != 0\n",
current_plugin);
continue;
}
/* define a counter group for every plugin*/
current->counter_group = vt_def_counter_group(VT_MY_THREAD, current_plugin);
/* now search for all available events on that plugin */
next_plugin_metric = env_vt_plugin_metrics;
while (next_plugin_metric[0] != 0) {
/* shall contain current index in environment VT_PLUGIN_METRICS */
index = 0;
/* copy metric to current_plugin_metric char by char */
while ((next_plugin_metric[index] != ':') && (next_plugin_metric[index]
!= '\0')) {
current_plugin_metric[index] = next_plugin_metric[index];
index++;
}
current_plugin_metric[index] = 0;
if (next_plugin_metric[index] == ':')
next_plugin_metric = &next_plugin_metric[index + 1];
else
next_plugin_metric = &next_plugin_metric[index];
/* If the plugin metric belongs to the current plugin */
if (strstr(current_plugin_metric, current_plugin)
== current_plugin_metric) {
/* some meta data*/
char * unit = NULL;
uint32_t otf_prop = 0;
/* This will be needed to iterate over the infos */
vt_plugin_cntr_metric_info * current_event_info;
/* check the event name from plugin */
/* it could contain wildcards and other stuff */
vt_plugin_cntr_metric_info * event_infos = info.get_event_info(
¤t_plugin_metric[strlen(current_plugin) + 1]);
vt_cntl_msg(3, "Adding metric %s for plugin counter library: lib%s.so",
current_plugin_metric, current_plugin);
/* check the event name from plugin */
/* it could contain wildcards and other stuff */
if (event_infos == NULL) {
vt_error_msg(
"Error initializing plugin metric %s, no info returned\n",
current_plugin_metric);
continue;
}
/* now for all events which are present in the struct */
current_event_info = event_infos;
for (current_event_info = event_infos;
current_event_info->name != NULL;
current_event_info++) {
vt_cntl_msg(3,
"Retrieved metric %s for plugin counter library: lib%s.so."
" Initializing data structures", current_event_info->name,
current_plugin);
/* event is part of this plugin */
current->num_selected_events++;
/* allocate space for events */
current->selected_events = realloc(current->selected_events,
current->num_selected_events * sizeof(char*));
/*the metric is everything after "plugin_"*/
current->selected_events[current->num_selected_events - 1]
= current_event_info->name;
current->vt_counter_ids = realloc(current->vt_counter_ids,
current->num_selected_events * sizeof(uint32_t));
current->vt_asynch_keys = realloc(current->vt_asynch_keys,
current->num_selected_events * sizeof(uint32_t));
/* if a unit is provided, use it */
unit = current_event_info->unit == NULL ? "#"
: current_event_info->unit;
/* if otf properties are provided, use them */
otf_prop = current_event_info->cntr_property;
/* define new counter */
current->vt_counter_ids[current->num_selected_events - 1]
= vt_def_counter(VT_MY_THREAD,
current->selected_events[current->num_selected_events - 1],
unit, otf_prop, current->counter_group, group);
switch (current->info.synch) {
case VT_PLUGIN_CNTR_SYNCH:
/* no asynch_keys at all */
break;
case VT_PLUGIN_CNTR_ASYNCH_POST_MORTEM:
/* One asynch_key for all */
current->vt_asynch_keys[current->num_selected_events - 1] = post_mortem_asynch_key();
break;
default:
{
char buffer[512];
sprintf(buffer, "%s_%s", current_plugin, current_event_info->name);
current->vt_asynch_keys[current->num_selected_events - 1]
= vt_def_async_source(VT_MY_THREAD, buffer);
}
break;
}
/* enable plugin counters */
vt_plugin_cntr_used = 1;
} /* end of: for all metrics related to the metric string */
if (event_infos != NULL)
free(event_infos);
} /* end of if metric belongs to this plugin */
} /* end of: for all plugin metrics */
} /* end of: for all plugins */
/* free temporary variables */
if (plugins != NULL)
free(plugins);
}
