void vt_plugin_cntr_thread_exit(VTThrd * thrd) {
uint32_t i, j;
struct vt_plugin_cntr_defines * defines =
(struct vt_plugin_cntr_defines *) thrd->plugin_cntr_defines;
vt_cntl_msg(3, "Process %i Thread %s-%s exits plugin counters ...",
vt_my_ptrace, thrd->name, thrd->name_suffix);
/* make sure that we can process */
if (defines == NULL)
return;
vt_plugin_cntr_thread_disable_counters(thrd);
/* free per thread resources */
if (defines->counters != NULL) {
for (i = 0; i < VT_PLUGIN_CNTR_SYNCH_TYPE_MAX; i++) {
if (defines->counters[i] != NULL) {
if (defines->size_of_counters != NULL) {
for (j = 0; j < defines->size_of_counters[i]; j++) {
#if (defined(VT_MT) || defined (VT_HYB) || defined(VT_JAVA))
if (defines->counters[i][j].callback_mutex!=NULL)
VTThrd_lock((VTThrdMutex **) &defines->counters[i][j].callback_mutex);
if (defines->counters[i][j].callback_values != NULL) {
free(defines->counters[i][j].callback_values);
defines->counters[i][j].callback_values = NULL;
vt_trace_off(thrd->tid, 0, 1);
}
if (defines->counters[i][j].callback_mutex != NULL) {
VTThrd_unlock((VTThrdMutex **) &defines->counters[i][j].callback_mutex);
VTThrd_deleteMutex((VTThrdMutex **) &(defines->counters[i][j].callback_mutex));
}
#endif /* VT_MT || VT_HYB || VT_JAVA */
}
}
free(defines->counters[i]);
}
}
free(defines->counters);
}
if (defines->size_of_counters != NULL)
free(defines->size_of_counters);
free(defines);
vt_cntl_msg(3, "Process %i Thread %s-%s exits plugin counters ... done",
vt_my_ptrace, thrd->name, thrd->name_suffix);
}
int vt_env_stat_props()
{
static int propflags = 0;
char* tmp;
if (propflags == 0)
{
tmp = getenv("VT_STAT_PROPS");
if (tmp != NULL && strlen(tmp) > 0)
{
char tmpbuf[128];
char* p;
char* tk;
int dc;
vt_cntl_msg(2, "VT_STAT_PROPS=%s", tmp);
p = tmpbuf;
strncpy(tmpbuf, tmp, 127);
tmpbuf[127] = '\0';
while( *p ) { *p = tolower(*p); p++; }
if (strcmp( tmpbuf, "all" ) == 0)
{
propflags = (VT_SUM_PROP_FUNC | VT_SUM_PROP_MSG | VT_SUM_PROP_COLLOP);
}
else
{
tk = strtok(tmpbuf, ":");
dc = 0;
propflags = 0;
do {
if (dc <= 2 &&
(strcmp( tk, "func" ) == 0))
propflags |= VT_SUM_PROP_FUNC;
else if(dc <= 2 &&
(strcmp( tk, "msg" ) == 0))
propflags |= VT_SUM_PROP_MSG;
else if(dc <= 2 &&
(strcmp( tk, "collop" ) == 0))
propflags |= VT_SUM_PROP_COLLOP;
/* else if(dc <= 3 &&
(strcmp( tk, "fileop" ) == 0))
propflags |= VT_SUM_PROP_FILEOP; */
else
vt_error_msg("VT_STAT_PROPS not properly set");
dc++;
} while((tk = strtok(0, ":")));
}
}
else
{
/* propflags =
(VT_SUM_PROP_FUNC | VT_SUM_PROP_MSG | VT_SUM_PROP_COLLOP | VT_SUM_PROP_FILEOP); */
propflags = (VT_SUM_PROP_FUNC | VT_SUM_PROP_MSG | VT_SUM_PROP_COLLOP);
}
}
return propflags;
}
/*
* Finalize the VampirTrace CUPTI context and free all memory allocated with it.
*
* @param vtCtx pointer to the VampirTrace CUPTI context
*/
void vt_cupti_finalizeCtx(vt_cupti_ctx_t *vtCtx)
{
if(vtCtx == NULL)
return;
/* write exit event for GPU idle time */
if(vt_gpu_trace_idle > 0 && vtCtx->strmList != NULL
#if defined(VT_CUPTI_ACTIVITY)
&& vtCtx->activity != NULL && vtCtx->activity->gpuIdleOn == 1
#endif
){
uint64_t idle_end = vt_pform_wtime();
/*vt_warning("IDLEexit: %llu (%d)", idle_end, vtCtx->strmList->vtThrdID);*/
vt_exit(vtCtx->strmList->vtThrdID, &idle_end);
}
/* cleanup stream list */
while(vtCtx->strmList != NULL){
vt_cupti_strm_t *vtStrm = vtCtx->strmList;
vtCtx->strmList = vtCtx->strmList->next;
free(vtStrm);
vtStrm = NULL;
}
/* free CUDA malloc entries, if user application has memory leaks */
while(vtCtx->gpuMemList != NULL){
vt_cupti_gpumem_t *vtMem = vtCtx->gpuMemList;
if(vt_gpu_trace_memusage > 1)
vt_cntl_msg(1, "[CUPTI] Free of %d bytes GPU memory missing!",
vtMem->size);
vtCtx->gpuMemList = vtMem->next;
free(vtMem);
vtMem = NULL;
}
#if defined(VT_CUPTI_ACTIVITY)
if(vtCtx->activity != NULL)
free(vtCtx->activity);
#endif
#if (defined(VT_CUPTI_CALLBACKS) && !defined(VT_CUPTI_ACTIVITY))
if(vtCtx->callbacks != NULL)
free(vtCtx->callbacks);
#endif
#if defined(VT_CUPTI_EVENTS)
if(vtCtx->events != NULL)
free(vtCtx->events);
#endif
free(vtCtx);
vtCtx = NULL;
}
static void vt_cuptievt_start(vt_cupti_events_t *vtcuptiEvtCtx)
{
CUptiResult cuptiErr = CUPTI_SUCCESS;
vt_cupti_evtgrp_t *vtcuptiGrp = NULL;
vt_cupti_evtgrp_t *lastGrp = NULL;
/* start gathering counter values, if context was successfully initialized */
if(NULL == vtcuptiEvtCtx){
/* no performance counters for this thread available */
VT_CHECK_THREAD;
vt_gpu_prop[VT_MY_THREAD] |= VTGPU_NO_PC;
vt_cntl_msg(2, "[CUPTI Events] Context not initialized!");
return;
}
/* start all groups */
vtcuptiGrp = vtcuptiEvtCtx->vtGrpList;
lastGrp = vtcuptiEvtCtx->vtGrpList;
while(vtcuptiGrp != NULL){
cuptiErr = cuptiEventGroupEnable(vtcuptiGrp->evtGrp);
/* if the event group could not be enabled, remove it */
if(cuptiErr != CUPTI_SUCCESS){
size_t i;
vt_cupti_evtgrp_t *freeGrp = vtcuptiGrp;
size_t valueSize = 32;
char name[32];
vtcuptiGrp = vtcuptiGrp->next;
/* give user information about the group, which cannot be enabled */
for(i = 0; i < freeGrp->evtNum; i++){
VTCUPTIEVENTGETATTRIBUTE(vtcuptiEvtCtx->vtDevCap->cuDev,
*(freeGrp->cuptiEvtIDs)+i,
CUPTI_EVENT_ATTR_NAME,
&valueSize, (char*)name);
vt_warning("[CUPTI Events] Event '%s' (%d) cannot be enabled",
name, *(freeGrp->cuptiEvtIDs)+i);
}
/* group is first element in linked list */
if(vtcuptiEvtCtx->vtGrpList == freeGrp){
vtcuptiEvtCtx->vtGrpList = vtcuptiEvtCtx->vtGrpList->next;
}else{/* has to be at least the second group in linked list */
lastGrp->next = freeGrp->next;
}
free(freeGrp);
freeGrp = NULL;
}else{
vtcuptiGrp->enabled = 1;
lastGrp= vtcuptiGrp;
vtcuptiGrp = vtcuptiGrp->next;
}
}
}
/*
* Initialize the CUPTI events data of the given VampirTrace CUPTI context.
*
* @param vtCtx pointer to the VampirTrace CUPTI context
*/
void vt_cupti_events_initContext(vt_cupti_ctx_t *vtcuptiCtx)
{
vt_cupti_events_t *vtcuptiEvtCtx = NULL;
vt_cntl_msg(2, "[CUPTI Events] Initializing VampirTrace CUPTI events context");
/* get a pointer to eventIDArray */
{
CUresult cuErr = CUDA_SUCCESS;
int dev_major, dev_minor;
vt_cupti_device_t *cuptiDev;
/* TODO: do not trace this driver API function call */
cuErr = cuDeviceComputeCapability(&dev_major, &dev_minor, vtcuptiCtx->cuDev);
VT_CUDRV_CALL(cuErr, "cuDeviceComputeCapability");
/* check if device capability already listed */
VT_CUPTI_LOCK();
cuptiDev = vtcuptievtCapList;
VT_CUPTI_UNLOCK();
cuptiDev = vt_cupti_checkMetricList(cuptiDev, dev_major, dev_minor);
if(cuptiDev){
/* allocate the VampirTrace CUPTI events context */
vtcuptiEvtCtx = (vt_cupti_events_t *)malloc(sizeof(vt_cupti_events_t));
if(vtcuptiEvtCtx == NULL)
vt_error_msg("[CUPTI Events] malloc(sizeof(vt_cupti_events_t)) failed!");
vtcuptiEvtCtx->vtDevCap = cuptiDev;
vtcuptiEvtCtx->vtGrpList = NULL;
vtcuptiEvtCtx->counterData = NULL;
vtcuptiEvtCtx->cuptiEvtIDs = NULL;
vtcuptiCtx->events = vtcuptiEvtCtx;
}else{
return;
}
}
/* create and add the VampirTrace CUPTI groups to the context */
vt_cupti_addEvtGrpsToCtx(vtcuptiCtx);
/* allocate memory for CUPTI counter reads */
{
size_t allocSize = vtcuptiEvtCtx->vtGrpList->evtNum;
vtcuptiEvtCtx->counterData =
(uint64_t *)malloc(allocSize*sizeof(uint64_t));
vtcuptiEvtCtx->cuptiEvtIDs =
(CUpti_EventID *)malloc(allocSize*sizeof(CUpti_EventID));
}
vt_cuptievt_start(vtcuptiEvtCtx);
}
static void vt_cupti_addEvtGrpsToCtx(vt_cupti_ctx_t *vtcuptiCtx)
{
CUptiResult cuptiErr = CUPTI_SUCCESS;
vt_cupti_evtgrp_t *vtcuptiGrp = vt_cuptievt_createEvtGrp(vtcuptiCtx);
vt_cupti_events_t *vtcuptiEvents = vtcuptiCtx->events;
vt_cupti_evtctr_t *vtcuptiEvt = vtcuptiEvents->vtDevCap->vtcuptiEvtList;
/* try to add all events for current context/device */
while(vtcuptiEvt != NULL && vtcuptiGrp->evtNum < vtcuptiEvents->vtDevCap->evtNum){
cuptiErr = cuptiEventGroupAddEvent(vtcuptiGrp->evtGrp,
vtcuptiEvt->cuptiEvtID);
/* everything is fine */
if(cuptiErr == CUPTI_SUCCESS){
vtcuptiGrp->cuptiEvtIDs[vtcuptiGrp->evtNum] = vtcuptiEvt->cuptiEvtID;
vtcuptiGrp->vtCIDs[vtcuptiGrp->evtNum] = vtcuptiEvt->vtCID;
vtcuptiGrp->evtNum++;
}else{
/* we can at least try to put the event in another group */
/* too many events in this group or
event is in different domain or device limitation*/
if(cuptiErr == CUPTI_ERROR_MAX_LIMIT_REACHED ||
cuptiErr == CUPTI_ERROR_NOT_COMPATIBLE){
vt_cntl_msg(2, "[CUPTI Events] Create new event group for event %d",
vtcuptiEvt->cuptiEvtID);
/* prepend last group to list, if it is not empty */
if(vtcuptiGrp->evtNum > 0){
vtcuptiGrp->next = vtcuptiEvents->vtGrpList;
vtcuptiEvents->vtGrpList = vtcuptiGrp;
}
/* create new VampirTrace CUPTI event group */
vtcuptiGrp = vt_cuptievt_createEvtGrp(vtcuptiCtx);
/* try to add the same event to the just created group */
continue;
}
PRINT_CUPTI_ERROR(cuptiErr, "cuptiEventGroupAddEvent");
}
vtcuptiEvt = vtcuptiEvt->next;
}
/* prepend last group to list, if it is not empty */
if(vtcuptiGrp->evtNum > 0){
vtcuptiGrp->next = vtcuptiEvents->vtGrpList;
vtcuptiEvents->vtGrpList = vtcuptiGrp;
}
}
void vt_metric_thread_init(long (*id_fn)(void))
{
int retval;
if ( nmetrics == 0 )
return;
retval = PAPI_thread_init((unsigned long (*)(void))(id_fn));
if ( retval != PAPI_OK)
metric_error(retval, "PAPI_thread_init");
vt_cntl_msg(2, "PAPI thread support initialized");
}
/*
* Finalizes CUPTI device.
*
* @param ptid VampirTrace process/thread id
* @param cleanExit 1 to cleanup CUPTI event group, otherwise 0
*/
void vt_cuptievt_finalize_device(uint8_t cleanExit){
CUptiResult cuptiErr = CUPTI_SUCCESS;
vt_cupti_ctx_t *vtcuptiCtx = NULL;
vt_cntl_msg(2, "[CUPTI Events] Finalize device ... ");
{
CUcontext cuCtx;
#if (defined(CUDA_VERSION) && (CUDA_VERSION < 4000))
VT_CUDRV_CALL(cuCtxPopCurrent(&cuCtx), "cuCtxPopCurrent");
VT_CUDRV_CALL(cuCtxPushCurrent(cuCtx), "cuCtxPushCurrent");
#else
VT_CUDRV_CALL(cuCtxGetCurrent(&cuCtx), "cuCtxGetCurrent");
#endif
vtcuptiCtx = vt_cupti_removeCtx(&cuCtx);
if(vtcuptiCtx == NULL)
return;
}
if(vtcuptiCtx->events == NULL)
return;
if(cleanExit && vt_gpu_debug != 0){
/*uint64_t time = vt_pform_wtime();
vt_cupti_resetCounter(vtcuptiCtx, 0, &time);*/
/* stop CUPTI counter capturing */
vt_cuptievt_stop(vtcuptiCtx->events);
/* destroy all CUPTI event groups, which have been created */
{
vt_cupti_evtgrp_t *vtcuptiGrp = vtcuptiCtx->events->vtGrpList;
while(vtcuptiGrp != NULL){
cuptiErr = cuptiEventGroupRemoveAllEvents(vtcuptiGrp->evtGrp);
VT_CUPTI_CALL(cuptiErr, "cuptiEventGroupRemoveAllEvents");
cuptiErr = cuptiEventGroupDestroy(vtcuptiGrp->evtGrp);
VT_CUPTI_CALL(cuptiErr, "cuptiEventGroupDestroy");
vtcuptiGrp = vtcuptiGrp->next;
}
}
}
/* free VampirTrace CUPTI event context */
vt_cuptievt_freeEventCtx(vtcuptiCtx->events);
}
/*
* Finalizes CUPTI device.
*
* @param cleanExit 1 to cleanup CUPTI event group, otherwise 0
*/
void vt_cupti_finalize_device(uint32_t ptid, uint8_t cleanExit){
CUptiResult cuptiErr = CUPTI_SUCCESS;
vt_cupti_ctx_t *vtcuptiCtx = NULL;
vt_cntl_msg(2, "[CUPTI] Finalize device ... ");
{
CUcontext cuCtx = NULL;
VT_SUSPEND_CUDA_TRACING(ptid);
#if (defined(CUDA_VERSION) && (CUDA_VERSION < 4000))
CHECK_CU_ERROR(cuCtxPopCurrent(&cuCtx), "cuCtxPopCurrent");
CHECK_CU_ERROR(cuCtxPushCurrent(cuCtx), "cuCtxPushCurrent");
#else
CHECK_CU_ERROR(cuCtxGetCurrent(&cuCtx), "cuCtxGetCurrent");
#endif
VT_RESUME_CUDA_TRACING(ptid);
vtcuptiCtx = vt_cupti_takeCtxFromList(cuCtx);
if(vtcuptiCtx == NULL) return;
}
if(cleanExit && vt_gpu_debug != 0){
/*uint64_t time = vt_pform_wtime();
vt_cupti_resetCounter(vtcuptiCtx, 0, &time);*/
/* stop CUPTI counter capturing */
vt_cupti_stop(vtcuptiCtx);
/* destroy all CUPTI event groups, which have been created */
{
vt_cupti_grp_t *vtcuptiGrp = vtcuptiCtx->vtGrpList;
while(vtcuptiGrp != NULL){
cuptiErr = cuptiEventGroupRemoveAllEvents(vtcuptiGrp->evtGrp);
CHECK_CUPTI_ERROR(cuptiErr, "cuptiEventGroupRemoveAllEvents");
cuptiErr = cuptiEventGroupDestroy(vtcuptiGrp->evtGrp);
CHECK_CUPTI_ERROR(cuptiErr, "cuptiEventGroupDestroy");
vtcuptiGrp = vtcuptiGrp->next;
}
}
}
/* free VampirTrace CUPTI context */
vt_cupti_freeCtx(vtcuptiCtx);
}
static void metricmap_free(metricmap_t* map)
{
if (map == NULL)
return;
vt_cntl_msg(3, "Metricmap free (head=0x%p):", map);
while (map != NULL) {
metricmap_t* next = map->next;
if (map->event_name != NULL) free(map->event_name);
if (map->alias_name != NULL) free(map->alias_name);
free(map);
map = next;
}
}
void vt_fork_waitchilds()
{
uint32_t i;
int status;
if ( nchilds == 0 ) return;
VT_SUSPEND_EXEC_TRACING(VT_CURRENT_THREAD);
/* wait until all child processes are terminated */
for( i = 0; i < nchilds; i++ )
{
vt_cntl_msg(2, "Waiting until child process %i terminated",
(int)childv[i]);
waitpid(childv[i], &status, 0);
vt_cntl_msg(2, "Child process %i terminated, leaving %u",
(int)childv[i], nchilds-i-1);
}
VT_RESUME_EXEC_TRACING(VT_CURRENT_THREAD);
}
/*
* Retrieve the VampirTrace CUPTI context from the CUDA context.
*
* @param cuCtx the CUDA context
* @param ptid the active VampirTrace thread id
*/
static vt_cupti_ctx_t* vt_cupti_getCtx(CUcontext cuCtx, uint32_t ptid)
{
vt_cupti_ctx_t *vtcuptiCtx = NULL;
/* check, if there has been at least one VampirTrace CUPTI context created */
if(vtcuptiCtxlist == NULL) vt_cupti_init();
/* check, if the current VampirTrace thread is enabled for GPU counters */
if((vt_gpu_prop[ptid] & VTGPU_NO_PC) == VTGPU_NO_PC)
return NULL;
/* check if CUDA context is listed (linear search) */
CUPTI_LOCK();
vtcuptiCtx = vtcuptiCtxlist;
while(vtcuptiCtx != NULL){
if(vtcuptiCtx->cuCtx == cuCtx){
CUPTI_UNLOCK();
/*vt_cntl_msg(1, "[CUPTI] host thread %d (MPI rank %d)", ptid, vt_my_trace);*/
return vtcuptiCtx;
}
vtcuptiCtx = vtcuptiCtx->next;
}
CUPTI_UNLOCK();
vt_cntl_msg(2, "[CUPTI] Context for VT tid %d unknown! Creating ... ", ptid);
vtcuptiCtx = vt_cupti_initCtx(ptid, cuCtx);
if(vtcuptiCtx != NULL){
vt_cupti_start(vtcuptiCtx);
}else{
/* no performance counters for this thread available */
vt_gpu_prop[ptid] |= VTGPU_NO_PC;
vt_cntl_msg(2, "[CUPTI] Could not initialize!");
}
return vtcuptiCtx;
}
/*
* Finalizes the VampirTrace CUPTI implementation.
*/
void vt_cupti_finalize()
{
if(!vt_cupti_finalized){
CUPTI_LOCK();
if(!vt_cupti_finalized){
vt_cntl_msg(2, "[CUPTI] Finalizing ...");
/* free VampirTrace CUPTI context structures (should already be freed) */
while(vtcuptiCtxlist != NULL){
vt_cupti_ctx_t *tmp = vtcuptiCtxlist;
vt_cupti_finish(vtcuptiCtxlist);
vtcuptiCtxlist = vtcuptiCtxlist->next;
free(tmp);
tmp = NULL;
}
/* free capability metric list */
while(vt_cupti_capList != NULL){
vt_cupti_dev_t *tmp = vt_cupti_capList;
vt_cupti_capList = vt_cupti_capList->next;
/* free VampirTrace CUPTI events */
while(tmp->vtcuptiEvtList != NULL){
vt_cupti_evt_t *tmpEvt = tmp->vtcuptiEvtList;
tmp->vtcuptiEvtList = tmp->vtcuptiEvtList->next;
free(tmpEvt);
tmpEvt = NULL;
}
free(tmp);
tmp = NULL;
}
vt_cupti_finalized = 1;
CUPTI_UNLOCK();
#if (defined(VT_MT) || defined (VT_HYB))
VTTHRD_LOCK_ENV();
VTThrd_deleteMutex(&VTThrdMutexCupti);
VTTHRD_UNLOCK_ENV();
#endif /* VT_MT || VT_HYB */
}
}
}
size_t vt_env_otf_bsize(void)
{
static size_t bsize = 0;
if (bsize == 0)
{
char* tmp = getenv("VT_OTF_BUFFER_SIZE");
if (tmp != NULL && strlen(tmp) > 0)
{
vt_cntl_msg(2, "VT_OTF_BUFFER_SIZE=%s", tmp);
bsize = parse_size(tmp);
}
}
return bsize;
}
size_t vt_env_compression_bsize(void)
{
static size_t bsize = 0;
if (bsize == 0)
{
char* tmp = getenv("VT_COMPRESSION_BUFFER_SIZE");
if (tmp != NULL && strlen(tmp) > 0)
{
vt_cntl_msg(2, "VT_COMPRESSION_BUFFER_SIZE=%s", tmp);
bsize = parse_size(tmp);
}
}
return bsize;
}
/*
* Handles errors returned from CUPTI function calls.
*
* @param ecode the CUDA driver API error code
* @param msg a message to get more detailed information about the error
* @param the corresponding file
* @param the line the error occurred
*/
void vt_cupti_handleError(CUptiResult err, const char* msg,
const char *file, const int line)
{
const char *errstr;
if(msg != NULL) vt_cntl_msg(1, msg);
cuptiGetResultString(err, &errstr);
if(vt_gpu_error){
vt_error_msg("[CUPTI] %s:%d:'%s'", file, line, errstr);
}else{
vt_warning("[CUPTI] %s:%d:'%s'", file, line, errstr);
}
}
size_t vt_env_cudatrace_bsize()
{
static size_t limit = 0;
if (limit == 0)
{
char* tmp = getenv("VT_CUDATRACE_BUFFER_SIZE");
if (tmp != NULL && strlen(tmp) > 0)
{
vt_cntl_msg(2, "VT_CUDATRACE_BUFFER_SIZE=%s", tmp);
limit = parse_size(tmp);
}
}
return limit;
}
/*
* Finalizes the VampirTrace CUPTI events interface.
*/
void vt_cupti_events_finalize()
{
if(!vt_cuptievt_finalized && vt_cuptievt_initialized){ /* fast check without lock */
VT_CUPTI_LOCK();
if(!vt_cuptievt_finalized && vt_cuptievt_initialized){
vt_cupti_ctx_t *vtcuptiCtxList = vt_cupti_ctxList;
/* needed because of the atexit in vt_cupti_events_init() */
VT_SUSPEND_MALLOC_TRACING(VT_CURRENT_THREAD);
vt_cntl_msg(2, "[CUPTI Events] Finalizing ...");
/* free VampirTrace CUPTI events context structures */
while(vtcuptiCtxList != NULL){
if(vtcuptiCtxList->events != NULL){
vt_cupti_events_finalizeContext(vtcuptiCtxList);
free(vtcuptiCtxList->events);
vtcuptiCtxList->events = NULL;
}
vtcuptiCtxList = vtcuptiCtxList->next;
}
/* free capability metric list */
while(vtcuptievtCapList != NULL){
vt_cupti_device_t *tmp = vtcuptievtCapList;
vtcuptievtCapList = vtcuptievtCapList->next;
/* free VampirTrace CUPTI events */
while(tmp->vtcuptiEvtList != NULL){
vt_cupti_evtctr_t *tmpEvt = tmp->vtcuptiEvtList;
tmp->vtcuptiEvtList = tmp->vtcuptiEvtList->next;
free(tmpEvt);
tmpEvt = NULL;
}
free(tmp);
tmp = NULL;
}
VT_RESUME_MALLOC_TRACING(VT_CURRENT_THREAD);
vt_cuptievt_finalized = 1;
VT_CUPTI_UNLOCK();
}
}
}
int vt_env_stat_msg_dtls()
{
static int dtlsflags = 0;
char* tmp;
if (dtlsflags == 0)
{
tmp = getenv("VT_STAT_MSG_DTLS");
if (tmp != NULL && strlen(tmp) > 0)
{
char tmpbuf[128];
char* p;
char* tk;
int dc;
vt_cntl_msg(2, "VT_STAT_MSG_DTLS=%s", tmp);
p = tmpbuf;
strncpy(tmpbuf, tmp, 127);
tmpbuf[127] = '\0';
while( *p ) { *p = tolower(*p); p++; }
tk = strtok(tmpbuf, ":");
dc = 0;
dtlsflags = 0;
do {
if (dc <= 2 &&
(strcmp( tk, "peer" ) == 0))
dtlsflags |= VT_SUM_MSG_DTL_PEER;
else if(dc <= 2 &&
(strcmp( tk, "comm" ) == 0))
dtlsflags |= VT_SUM_MSG_DTL_COMM;
else if(dc <= 2 &&
(strcmp( tk, "tag" ) == 0))
dtlsflags |= VT_SUM_MSG_DTL_TAG;
else
vt_error_msg("VT_STAT_MSG_DTLS not properly set");
dc++;
} while((tk = strtok(0, ":")));
}
else
{
dtlsflags = VT_SUM_MSG_DTL_PEER;
}
}
return dtlsflags;
}
/*
* Destroy a VampirTrace CUPTI Activity context.
*
* @param vtcuptiActCtx VampirTrace CUPTI Activity context
*/
static void vt_cuptiact_destroyContext(vt_cupti_activity_t *vtcuptiActCtx)
{
if(vtcuptiActCtx == NULL)
return;
/* write exit event for GPU idle time */
if(vt_gpu_trace_idle == 1 && vtcuptiActCtx->gpuIdleOn == 1){
uint64_t idle_end = vt_pform_wtime();
/*vt_warning("IDLEexit: %llu (%d)", idle_end, vtCtx->strmList->vtThrdID);*/
vt_exit(vtcuptiActCtx->strmList->vtThrdID, &idle_end);
/*vtCtx->gpuIdleOn = 0;*/
}
/* cleanup stream list */
while(vtcuptiActCtx->strmList != NULL){
vt_cuptiact_strm_t *vtStrm = vtcuptiActCtx->strmList;
vtcuptiActCtx->strmList = vtcuptiActCtx->strmList->next;
free(vtStrm);
vtStrm = NULL;
}
/* free CUDA malloc entries, if user application has memory leaks */
while(vtcuptiActCtx->gpuMemList != NULL){
vt_cupti_gpumem_t *vtMem = vtcuptiActCtx->gpuMemList;
if(vt_gpu_trace_memusage > 1)
vt_cntl_msg(1, "[CUPTI Activity] Free of %d bytes GPU memory missing!",
vtMem->size);
vtcuptiActCtx->gpuMemList = vtMem->next;
free(vtMem);
vtMem = NULL;
}
/* free activity buffer */
if(vtcuptiActCtx->buffer != NULL){
free(vtcuptiActCtx->buffer);
vtcuptiActCtx->buffer = NULL;
}
free(vtcuptiActCtx);
}
int vt_env_mode()
{
static int modeflags = 0;
char* tmp;
if (modeflags == 0)
{
tmp = getenv("VT_MODE");
if (tmp != NULL && strlen(tmp) > 0)
{
char tmpbuf[128];
char* p;
char* tk;
int dc;
vt_cntl_msg(2, "VT_MODE=%s", tmp);
p = tmpbuf;
strncpy(tmpbuf, tmp, 127);
tmpbuf[127] = '\0';
while( *p ) { *p = tolower(*p); p++; }
tk = strtok(tmpbuf, ":");
dc = 0;
modeflags = 0;
do {
if (dc <= 1 &&
(strcmp( tk, "trace" ) == 0))
modeflags |= VT_MODE_TRACE;
else if(dc <= 1 &&
(strcmp( tk, "stat" ) == 0))
modeflags |= VT_MODE_STAT;
else
vt_error_msg("VT_MODE not properly set");
dc++;
} while((tk = strtok(0, ":")));
}
else
{
modeflags = VT_MODE_TRACE;
}
}
return modeflags;
}
char* vt_env_iofsl_servers()
{
static int read = 1;
static char* iofsl_servers = NULL;
char* tmp;
if (read)
{
read = 0;
tmp = getenv("VT_IOFSL_SERVERS");
if (tmp && strlen(tmp) > 0)
{
vt_cntl_msg(2, "VT_IOFSL_SERVERS=%s", tmp);
iofsl_servers = tmp;
}
}
return iofsl_servers;
}
void vt_cupti_init()
{
if(!vt_cupti_initialized){
#if (defined(VT_MT) || defined(VT_HYB))
VTThrd_createMutex(&VTThrdMutexCupti);
#endif
VT_CUPTI_LOCK();
if(!vt_cupti_initialized){
vt_cntl_msg(2, "[CUPTI] Initializing ... ");
/* register the finalize function of VampirTrace CUPTI to be called before
* the program exits */
atexit(vt_cupti_finalize);
vt_cupti_initialized = 1;
VT_CUPTI_UNLOCK();
}
}
}
char* vt_env_metrics()
{
static int read = 1;
static char* metrics = NULL;
char* tmp;
if (read)
{
read = 0;
tmp = getenv("VT_METRICS");
if (tmp && strlen(tmp) > 0)
{
vt_cntl_msg(2, "VT_METRICS=%s", tmp);
metrics = tmp;
}
}
return metrics;
}
char* vt_env_java_filter_spec()
{
static int read = 1;
static char* spec = NULL;
char* tmp;
if (read)
{
read = 0;
tmp = getenv("VT_JAVA_FILTER_SPEC");
if (tmp != NULL && strlen(tmp) > 0)
{
vt_cntl_msg(2, "VT_JAVA_FILTER_SPEC=%s", tmp);
spec = replace_vars(tmp);
}
}
return spec;
}
char* vt_env_groups_spec()
{
static int read = 1;
static char* spec = NULL;
char* tmp;
if (read)
{
read = 0;
tmp = getenv("VT_GROUPS_SPEC");
if (tmp != NULL && strlen(tmp) > 0)
{
vt_cntl_msg(2, "VT_GROUPS_SPEC=%s", tmp);
spec = replace_vars(tmp);
}
}
return spec;
}
char* vt_env_dyn_shlibs()
{
static int read = 1;
static char* dyn_shlibs = NULL;
char* tmp;
if (read)
{
read = 0;
tmp = getenv("VT_DYN_SHLIBS");
if (tmp != NULL && strlen(tmp) > 0)
{
vt_cntl_msg(2, "VT_DYN_SHLIBS=%s", tmp);
dyn_shlibs = replace_vars(tmp);
}
}
return dyn_shlibs;
}
char* vt_env_cupti_events()
{
static int read = 1;
static char* events = NULL;
char* tmp;
if (read)
{
read = 0;
tmp = getenv("VT_CUPTI_METRICS");
if (tmp && strlen(tmp) > 0)
{
vt_cntl_msg(2, "VT_CUPTI_METRICS=%s", tmp);
events = tmp;
}
}
return events;
}
char* vt_env_gputrace()
{
static int read = 1;
static char* args = NULL;
char* tmp;
if (read)
{
read = 0;
tmp = getenv("VT_GPUTRACE");
if (tmp && strlen(tmp) > 0)
{
vt_cntl_msg(2, "VT_GPUTRACE=%s", tmp);
args = tmp;
}
}
return args;
}
char* vt_env_gnu_nmfile()
{
static int read = 1;
static char* gnu_nmfile = NULL;
char* tmp;
if (read)
{
read = 0;
tmp = getenv("VT_GNU_NMFILE");
if (tmp != NULL && strlen(tmp) > 0)
{
vt_cntl_msg(2, "VT_GNU_NMFILE=%s", tmp);
gnu_nmfile = replace_vars(tmp);
}
}
return gnu_nmfile;
}
