自学教程：C++ vt_cntl_msg函数代码示例

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;}