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

void vt_metric_read(struct vt_metv* metv, uint64_t offsets[],                    uint64_t values[]){  int i;  if ( metv == NULL )    return;  /* read counter values of set */  if ( cpc_set_sample(cpc, metv->set, metv->buffer) == -1 )    vt_error_msg("cpc_set_sample: %s", strerror(errno));  for ( i = 0; i < nmetrics; i++ )  {    /* get 64-bit counter values from CPC buffer */    if ( cpc_buf_get(cpc, metv->buffer, metv->indices[i], &(values[i])) == -1 )      break;  }  if ( i != nmetrics )    vt_error_msg("cpc_buf_get: %s", strerror(errno));  /* add offsets to values, if necessary */  if ( offsets != NULL )  {    for ( i = 0; i < nmetrics; i++ )      values[i] += offsets[i];  }}

void vt_comm_free(MPI_Comm comm){  /* if only one communicator exists, we just need to decrease last_comm */  if (last_comm == 1 && comms[0].comm == comm)    {      last_comm = 0;    }  /* if more than one communicator exists, we need to search for the entry */  else if (last_comm > 1)    {      uint32_t i;      if ((i = comm_search(comm)) != (uint32_t)-1)        {          /* swap deletion candidate with last entry in the list */          comms[i] = comms[--last_comm];        }      else        {          vt_error_msg("vt_comm_free1: Cannot find communicator");        }    }  else    {      vt_error_msg("vt_comm_free2: Cannot find communicator");    }}

void vt_group_free(MPI_Group group){  if (last_group == 1 && groups[0].group == group)    {      groups[0].refcnt--;      if (groups[0].refcnt == 0)        last_group--;    }  else if (last_group > 1)    {      uint32_t i;      if ((i = group_search(group)) != (uint32_t)-1)        {          /* decrease reference count on entry */          groups[i].refcnt--;          /* check if entry can be deleted */          if (groups[i].refcnt == 0)            groups[i] = groups[--last_group];        }      else        {          vt_error_msg("vt_group_free1: Cannot find group");        }    }  else    {      vt_error_msg("vt_group_free2: Cannot find group");    }}

/* platform specific initialization */void vt_pform_init() {  int  pid = getpid();  char exec_proc[VT_PATH_MAX];  char exec[VT_PATH_MAX];  int  exec_len;  int  hostid_retries;#if TIMER == TIMER_MMTIMER  int fd;  unsigned long femtosecs_per_tick = 0;  int offset;  if((fd = open(MMTIMER_FULLNAME, O_RDONLY)) == -1) {    vt_error_msg("Failed to open " MMTIMER_FULLNAME);  }  if ((offset = ioctl(fd, MMTIMER_GETOFFSET, 0)) == -ENOSYS) {    vt_error_msg("Cannot get mmtimer offset");  }  if ((mmdev_timer_addr = mmap(0, getpagesize(), PROT_READ, MAP_SHARED, fd, 0))       == MAP_FAILED) {    vt_error_msg("Cannot mmap mmtimer");  }  mmdev_timer_addr += offset;  ioctl(fd, MMTIMER_GETRES, &femtosecs_per_tick);  mmdev_ticks_per_sec = (uint64_t)(1.0 / (1e-15 * femtosecs_per_tick));  close(fd);#elif TIMER == TIMER_CLOCK_GETTIME  struct timespec tp;  clock_gettime(CLOCK_REALTIME, &tp);  vt_time_base = tp.tv_sec - (tp.tv_sec & 0xFF);#elif TIMER == TIMER_PAPI_REAL_USEC  vt_time_base = vt_metric_real_usec();#endif  /* get full path of executable */  snprintf(exec_proc, sizeof (exec_proc), VT_PROCDIR"%d/exe", pid);  exec_len = readlink(exec_proc, exec, sizeof (exec)-1);  if(exec_len != -1)  {    exec[exec_len] = '/0';    vt_exec = strdup(exec);  }  /* get unique numeric SMP-node identifier */  hostid_retries = 0;  while( !vt_node_id && (hostid_retries++ < VT_MAX_GETHOSTID_RETRIES) ) {    vt_node_id = gethostid();  }  if (!vt_node_id)    vt_error_msg("Maximum retries (%i) for gethostid exceeded!",		 VT_MAX_GETHOSTID_RETRIES);}

void vt_metric_free(struct vt_metv* metv, uint32_t tid){  (void)tid;    if ( metv == NULL )    return;  if ( cpc_buf_destroy(cpc, metv->buffer) == -1 )    vt_error_msg("cpc_buf_destroy: %s", strerror(errno));  if ( cpc_set_destroy(cpc, metv->set) == -1 )    vt_error_msg("cpc_set_destroy: %s", strerror(errno));  free(metv);}

size_t vt_env_thread_bsize(){  static size_t buffer_size = 0;  char* tmp;  if (buffer_size == 0)    {      tmp = getenv("VT_THREAD_BUFFER_SIZE");      if (tmp != NULL && strlen(tmp) > 0)        {          vt_cntl_msg(2, "VT_THREAD_BUFFER_SIZE=%s", tmp);          buffer_size = parse_size(tmp);          if (buffer_size <= 0)            {              vt_error_msg("VT_BUFFER_SIZE not properly set");            }          else if (buffer_size < VT_MIN_BUFSIZE)            {              vt_warning("VT_BUFFER_SIZE=%d resized to %d bytes",                          buffer_size, VT_MIN_BUFSIZE);              buffer_size = VT_MIN_BUFSIZE;            }        }      else        {          buffer_size = 0;        }    }  return buffer_size;}

int vt_env_iofsl_mode(){  static int mode = -1;  char* tmp;  if (mode == -1)    {      tmp = getenv("VT_IOFSL_MODE");      if (tmp != NULL && strlen(tmp) > 0)        {          char tmpbuf[128];          char* p;          vt_cntl_msg(2, "VT_IOFSL_MODE=%s", tmp);          p = tmpbuf;          strncpy(tmpbuf, tmp, 127);          tmpbuf[127] = '/0';          while( *p ) { *p = tolower(*p); p++; }          if (strcmp(tmpbuf, "multifile") == 0)            mode = VT_IOFSL_MODE_MULTIFILE;          else if (strcmp(tmpbuf, "multifile_split") == 0)            mode = VT_IOFSL_MODE_MULTIFILE_SPLIT;          else            vt_error_msg("VT_IOFSL_MODE not properly set");        }      else        {          mode = VT_IOFSL_MODE_MULTIFILE_SPLIT;        }    }  return mode;}

void vt_env_cudatrace(){  char* tmp = getenv("VT_CUDATRACE");  if (tmp != NULL && strlen(tmp) > 0)    {      /* split error message in three parts due to C89 limitations */       char* error_msg[3] = {        "VT_CUDATRACE has been replaced by VT_GPUTRACE!/n"        "Usage: export VT_GPUTRACE=option1,option2,option2,.../n"        "The following CUDA measurement options are available:/n"        " cuda      : enable CUDA (needed to use CUDA runtime API wrapper)/n"        " cupti     : use the CUPTI interface instead of the library wrapper/n",        " runtime   : CUDA runtime API/n"        " driver    : CUDA driver API/n"        " kernel    : CUDA kernels/n"        " concurrent: enable concurrent kernel tracing at initialization time/n"        " idle      : GPU compute idle time/n"        " memcpy    : CUDA memory copies/n"        " memusage  : CUDA memory allocation/n"        " debug     : CUDA tracing debug mode/n"        " error     : CUDA errors will exit the program/n"        " yes|default: same as 'cuda,runtime,kernel,memcpy'/n"        " no: disable CUDA measurement/n",                "VT_CUDATRACE_CUPTI, VT_CUDATRACE_MEMCPY, VT_GPUTRACE_IDLE, "        "VT_GPUTRACE_ERROR have been replaced by VT_GPUTRACE as well!/n"        "Read the user manual for further information!/n" };      vt_error_msg("%s%s%s", error_msg[0], error_msg[1], error_msg[2]);    }}

void vt_request_free(struct VTRequest* req){  /* delete request by copying last request in place of req */   if (!lastreq) {    vt_error_msg("INTERNAL ERROR in request handling - no last request");  }  *req = *lastreq;  lastreq->flags = ERF_NONE;  lastreq->request = 0;  /* adjust pointer to last request */  lastidx--;  if (lastidx < 0)     {      /* reached low end of block */      if (last_block->prev) 	{	  /* goto previous block if existing */	  lastidx = VT_REQBLK_SIZE-1;	  lastreq = &(last_block->prev->req[lastidx]);	}       else 	{	  /* no previous block: re-initialize */	  lastidx = VT_REQBLK_SIZE;	  lastreq = 0;	}      last_block = last_block->prev;    }   else     {      lastreq--;    }  }

int vt_metric_open(){  char* env;  char* env_sep;  char* var;  char* token;  /* read environment variable "VT_METRICS" */  if ( ( env = vt_env_metrics() ) == NULL )    return 0;  env_sep = vt_env_metrics_sep();  var = strdup(env);  vt_cntl_msg(2, "VT_METRICS=%s", var);  /* initialize CPC */  if ( ( cpc = cpc_open(CPC_VER_CURRENT) ) == NULL )    vt_error_msg("cpc_open: %s", strerror(errno));  /* read metrics from specification string */  token = strtok(var, env_sep);  while ( token && (nmetrics < VT_METRIC_MAXNUM) )  {    metricv_add( token );    token = strtok(NULL, env_sep);  }  free(var);  return nmetrics;}

/* * Create a VampirTrace CUPTI activity context. *  * @return pointer to created VampirTrace CUPTI Activity context */static vt_cupti_activity_t* vt_cuptiact_createCtxActivity(CUcontext cuCtx){  vt_cupti_activity_t* vtCtxAct = NULL;    /* create new context, as it is not listed */  vtCtxAct = (vt_cupti_activity_t *)malloc(sizeof(vt_cupti_activity_t));  if(vtCtxAct == NULL)     vt_error_msg("[CUPTI Activity] Could not allocate memory for activity context!");  vtCtxAct->strmList = NULL;  vtCtxAct->gpuMemAllocated = 0;  vtCtxAct->gpuMemList = NULL;  vtCtxAct->buffer = NULL;  vtCtxAct->vtLastGPUTime = vt_gpu_init_time;  vtCtxAct->gpuIdleOn = 1;    /*    * Get time synchronization factor between host and GPU time for measurement    * interval    */  {    VT_CUPTI_CALL(cuptiGetTimestamp(&(vtCtxAct->sync.gpuStart)), "cuptiGetTimestamp");    vtCtxAct->sync.hostStart = vt_pform_wtime();  }      /* set default CUPTI stream ID (needed for memory usage and idle tracing) */  VT_CUPTI_CALL(cuptiGetStreamId(cuCtx, NULL, &(vtCtxAct->defaultStrmID)),                                  "cuptiGetStreamId");    return vtCtxAct;}

/* platform specific initialization */void vt_pform_init() {  int  pid = getpid();  char exec_proc[512];  int  hostid_retries;#if TIMER == TIMER_SWITCH_CLOCK  int i;  for (i=0; i<NUMRETRY; i++) {    if ( (vt_swclk = swclockInit()) != 0 ) break;  }#elif TIMER == TIMER_POWER_REALTIME  timebasestruct_t t;  read_real_time(&t, TIMEBASE_SZ);  time_base_to_time(&t, TIMEBASE_SZ);  vt_time_base = t.tb_high - (t.tb_high & 0xFFFF);#elif TIMER == TIMER_PAPI_REAL_USEC  vt_time_base = vt_metric_real_usec();#endif  /* get full path of executable */  snprintf(exec_proc, sizeof (exec_proc), VT_PROCDIR"%d/object/a.out", pid);  vt_exec = strdup(exec_proc);  /* get unique numeric SMP-node identifier */  hostid_retries = 0;  while( !vt_node_id && (hostid_retries++ < VT_MAX_GETHOSTID_RETRIES) ) {    vt_node_id = gethostid();  }  if (!vt_node_id)    vt_error_msg("Maximum retries (%i) for gethostid exceeded!",		 VT_MAX_GETHOSTID_RETRIES);}

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

/* * Create a VampirTrace CUPTI Activity context. *  * @param ctxID ID of the CUDA context * @param devID ID of the CUDA device *  * @return pointer to created VampirTrace CUPTI Activity context */static vt_cuptiact_ctx_t* vt_cuptiact_createContext(uint32_t ctxID,                                                     CUcontext cuCtx,                                                     uint32_t devID){  vt_cuptiact_ctx_t* vtCtx = NULL;    /* create new context, as it is not listed */  vtCtx = (vt_cuptiact_ctx_t *)malloc(sizeof(vt_cuptiact_ctx_t));  if(vtCtx == NULL)     vt_error_msg("[CUPTI Activity] Could not allocate memory for context!");  vtCtx->ctxID = ctxID;  vtCtx->next = NULL;  vtCtx->strmList = NULL;  vtCtx->gpuMemAllocated = 0;  vtCtx->gpuMemList = NULL;  vtCtx->buffer = NULL;  vtCtx->vtLastGPUTime = vt_gpu_init_time;  vtCtx->gpuIdleOn = 1;    /*    * Get time synchronization factor between host and GPU time for measurement    * interval    */  {    VT_CUPTI_CALL(cuptiGetTimestamp(&(vtCtx->sync.gpuStart)), "cuptiGetTimestamp");    vtCtx->sync.hostStart = vt_pform_wtime();  }    VT_CHECK_THREAD;  vtCtx->ptid = VT_MY_THREAD;    if(cuCtx == NULL) CHECK_CU_ERROR(cuCtxGetCurrent(&cuCtx), NULL);  vtCtx->cuCtx = cuCtx;    /* set default CUPTI stream ID (needed for memory usage and idle tracing) */  VT_CUPTI_CALL(cuptiGetStreamId(vtCtx->cuCtx, NULL, &(vtCtx->defaultStrmID)),                                  "cuptiGetStreamId");    if(devID == (uint32_t)-1){    CUdevice cuDev;        /* driver API prog: correct cuDev, but result is 201 (invalid context) */    if(CUDA_SUCCESS != cuCtxGetDevice(&cuDev)){      devID = VT_NO_ID;    }else{      devID = (uint32_t)cuDev;    }  }    vtCtx->devID = devID;  vtCtx->cuDev = devID;    /*vt_cntl_msg(1,"device id: %d", devID);*/    return vtCtx;}

int vt_metric_open(){  int i;  char* env;  char* env_sep;  char* var;  char* token;  const int max_metrics = sizeof (vt_sx_metrics) / sizeof (vt_sx_metrics[0]);  /* read environment variable "VT_METRICS"; return if unset. */  env = vt_env_metrics();  if ( env == NULL )    return nmetrics;  env_sep = vt_env_metrics_sep();  var = strdup(env);  vt_cntl_msg(2, "VT_METRICS=%s", var);  /* convert VT_METRICS's letters to lower case */  token = var;  while ( *token ) { *token = tolower(*token); token++; }  /* read metrics from specification string */  token = strtok(var, env_sep);  if (token && (0 == strcmp (token, "all"))) {    vt_cntl_msg(2, "token:%s Adding all metrics", token);    for (i = 0; i < max_metrics; i++) {      metricv_add(i);      vt_cntl_msg(2, "metric i:%d name:%s", i, vt_sx_metrics[i].name);    }  } else {    while ( token && (nmetrics < VT_METRIC_MAXNUM) ) {      /* search metricmap for a suitable definition */      /* printf("Token%d: <%s>/n", nmetrics, token); */      for (i = 0; i < max_metrics; i++) {	if (0 == strcmp (token, vt_sx_metrics[i].name)) {	  metricv_add(i);	  vt_cntl_msg(2, "metric i:%d token:%s", i, token);	  break;	}      }      if (i == max_metrics) {	vt_error_msg ("Metric <%s> not supported", token);      }      token = strtok(NULL, env_sep);    }  }  sx_ctr_array = calloc(SX_CTR_MAX, sizeof (uint64_t));  /* clean up */  free(var);  return nmetrics;}

static void metric_error(int errcode, char *note){  char errstring[PAPI_MAX_STR_LEN];  PAPI_perror(errcode, errstring, PAPI_MAX_STR_LEN);  if (errcode == PAPI_ESYS) {    strncat(errstring, ": ", PAPI_MAX_STR_LEN-strlen(errstring));    strncat(errstring, strerror(errno), PAPI_MAX_STR_LEN-strlen(errstring));  }  vt_error_msg("%s: %s (fatal)/n", note?note:"PAPI", errstring);}

/* * 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);}

void vt_mpifile_init(){  if( !mpifile_initialized )  {    struct rlimit rl;    mpifile_gid = vt_def_file_group( VT_CURRENT_THREAD, "MPI I/O" );    if( getrlimit(RLIMIT_NOFILE, &rl) )      vt_error_msg( "getrlimit() failed reading max no. of open files" );    nmaxfiles = (rl.rlim_cur == RLIM_INFINITY) ? 131072 : (int)rl.rlim_cur;    mpifh_fid_map  = (struct mpifh_fid_map*)calloc( nmaxfiles, sizeof(struct mpifh_fid_map) );    if( !mpifh_fid_map )      vt_error_msg( "Out of memory while allocating %i MPI_File handles", nmaxfiles );    nfiles = 0;    memset( htab_mpifile, 0, sizeof(htab_mpifile) );    mpifile_initialized = 1;  }}

void vt_win_set_gid( MPI_Win win, uint32_t gid ){  uint32_t i = win_search(win);  if ( i != (uint32_t)-1 )    {      wins[i].gid = gid;    }  else    {      vt_error_msg("Cannot find window");    }}

void vt_metric_thread_init(long (*id_fn)(void)){  (void)id_fn;  if ( nmetrics == 0 )    return;  /* we don't support threads for the moment */#if (defined(VT_MT) || defined(VT_HYB) || defined(VT_JAVA))  vt_error_msg("NEC SX Performance Counters for threaded application "               "not yet supported");#endif /* VT_MT || VT_HYB || VT_JAVA */}

struct vt_metv* vt_metric_create(){  struct vt_metv* metv;  int i;  if ( nmetrics == 0 )    return NULL;  metv = (struct vt_metv*)malloc(sizeof(struct vt_metv));  if ( metv == NULL )    vt_error();  /* create CPC set */  metv->set = NULL;  if ( ( metv->set = cpc_set_create(cpc) ) == NULL )    vt_error_msg("cpc_set_create: %s", strerror(errno));  metv->indices = (int*)calloc(nmetrics, sizeof(int));  for ( i = 0; i < nmetrics; i++ )  {    /* add request to set and store the corresponding index */    metv->indices[i] = cpc_set_add_request(cpc, metv->set,					   metricv[i]->name, 0,					   CPC_COUNT_USER, 0, NULL);    if ( metv->indices[i] == -1 )      vt_error_msg("cpc_set_add_request (%s): %s", metricv[i]->name,		   strerror(errno));  }  /* create CPC buffer */  if ( ( metv->buffer = cpc_buf_create(cpc, metv->set) ) == NULL )    vt_error_msg("cpc_buf_create: %s", strerror(errno));  /* bind set to the calling LWP */  if ( cpc_bind_curlwp(cpc, metv->set, 0) == -1 )    vt_error_msg("cpc_bind_curlwp: %s",  strerror(errno));  return metv;}

static void metricv_add(char* name, int code){    if (nmetrics >= VT_METRIC_MAXNUM)        vt_error_msg("Number of counters exceeds VampirTrace allowed maximum of %d/n",                     VT_METRIC_MAXNUM);    else {        metricv[nmetrics] = (struct metric*)malloc(sizeof(struct metric));        metricv[nmetrics]->name = strdup(name);        metricv[nmetrics]->descr[0] = '/0';        metricv[nmetrics]->papi_code = code;        nmetrics++;    }}

/* * Create a VampirTrace CUPTI Activity stream. *  * @param devID ID of the CUDA device * @param strmID ID of the CUDA stream *  * @return pointer to created VampirTrace CUPTI Activity stream */static vt_cuptiact_strm_t* vt_cuptiact_createStream(vt_cupti_ctx_t *vtCtx,                                                     uint32_t strmID){  vt_cuptiact_strm_t *vtStrm = NULL;    vtStrm = (vt_cuptiact_strm_t *)malloc(sizeof(vt_cuptiact_strm_t));  if(vtStrm == NULL)    vt_error_msg("[CUPTI Activity] Could not allocate memory for stream!");  vtStrm->strmID = strmID;  vtStrm->vtLastTime = vt_gpu_init_time;  vtStrm->destroyed = 0;  vtStrm->next = NULL;    /* create VT-User-Thread with name and parent id and get its id */  {    char thread_name[16] = "CUDA";    if(vt_gpu_stream_reuse){      if(vtCtx->devID != VT_NO_ID){        if(-1 == snprintf(thread_name+4, 12, "[%d]", vtCtx->devID))          vt_cntl_msg(1, "Could not create thread name for CUDA thread!");      }    }else{      if(vtCtx->devID == VT_NO_ID){        if(-1 == snprintf(thread_name+4, 12, "[?:%d]", strmID))          vt_cntl_msg(1, "Could not create thread name for CUDA thread!");      }else{        if(-1 == snprintf(thread_name+4, 12, "[%d:%d]", vtCtx->devID, strmID))          vt_cntl_msg(1, "Could not create thread name for CUDA thread!");      }    }        VT_CHECK_THREAD;    vt_gpu_registerThread(thread_name, VT_MY_THREAD, &(vtStrm->vtThrdID));  }    /* if first stream created for this device, make it the default stream */  if(vtCtx->activity->strmList == NULL){    /* write enter event for GPU_IDLE on first stream */    if(vt_gpu_trace_idle == 1){      if(vt_gpu_init_time < vt_start_time)        vt_gpu_init_time = vt_start_time;                vt_enter(vtStrm->vtThrdID, &vt_gpu_init_time, vt_gpu_rid_idle);      /*vt_warning("IDLEente: %llu (%d)", vt_gpu_init_time, vtStrm->vtThrdID);*/      vtCtx->activity->gpuIdleOn = 1;    }  }    return vtStrm;}

uint32_t vt_fork_get_num_childs_tot(){  uint32_t nchilds_tot;  /* any fork performed? (trace-id file exists?) */  if ( fork_performed )  {    int fd;    char tmp[16] = "";    vt_libassert(trcid_filename[0] != '/0');    VT_SUSPEND_IO_TRACING(VT_CURRENT_THREAD);    /* open temp. id file for reading */    if ( (fd = open(trcid_filename, O_RDONLY)) == -1 )      vt_error_msg("Cannot open file %s: %s", trcid_filename, strerror(errno));    /* read current trace id */    if ( read(fd, tmp, 16) == -1 )      vt_error_msg("Cannot read file %s: %s", trcid_filename, strerror(errno));    vt_libassert(tmp[0] != '/0');    nchilds_tot = atoi(tmp);    vt_libassert(nchilds_tot > 0);    /* close temp. id file */    close(fd);    VT_RESUME_IO_TRACING(VT_CURRENT_THREAD);  }  else  {    nchilds_tot = 0;  }    return nchilds_tot;}

/* Save the mapping fh-->id */static vt_mpifile_data* store_id( const MPI_File fh, const uint32_t id ){  struct mpifh_fid_map *newentry;  if( nfiles >= nmaxfiles )     vt_error_msg( "Too many MPI_File handles" );  /* nfiles is always the index to the next free entry */  newentry = &(mpifh_fid_map[nfiles]);  newentry->mpifh = fh;  newentry->file_data.fid = id;  newentry->file_data.handle = VTTHRD_IO_NEXT_HANDLE(VTTHRD_MY_VTTHRD);  nfiles++;  return &(newentry->file_data);}

uint32_t vt_group_id(MPI_Group group){  uint32_t i;  if ((i = group_search(group)) != (uint32_t)-1)    {      return groups[i].gid;    }  else    {      vt_error_msg("Cannot find group");      return (uint32_t)-1;    }}

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

uint32_t vt_comm_id(MPI_Comm comm){  uint32_t i;  if ((i = comm_search(comm)) != (uint32_t)-1)    {      return comms[i].cid;    }  else    {      vt_error_msg("Cannot find communicator");      return (uint32_t)-1;    }}

void vt_getcpu_read(uint32_t* value, uint8_t* changed){  int cpuid;  *changed = 0;  if ( (cpuid = sched_getcpu()) == -1 )    vt_error_msg("sched_getcpu: %s", strerror(errno));  if( (uint32_t)cpuid != *value )  {    *value = (uint32_t)cpuid;    *changed = 1;  }}

/* * 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);  }}