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

void initialize_ocl(cl_vars_t& cv){  cv.err = clGetPlatformIDs(1, &(cv.platform), &(cv.platforms));  CHK_ERR(cv.err);  cv.err = clGetDeviceIDs(cv.platform, CL_DEVICE_TYPE_GPU, 1, &(cv.device_id), NULL);  CHK_ERR(cv.err);  cv.context = clCreateContext(0, 1, &(cv.device_id), NULL, NULL, &(cv.err));  CHK_ERR(cv.err);  cv.commands = clCreateCommandQueue(cv.context, cv.device_id, 				     CL_QUEUE_PROFILING_ENABLE, &(cv.err));  CHK_ERR(cv.err);#ifdef DEBUG  std::cout << "CL fill vars success" << std::endl;  // Device info  cl_ulong mem_size;  cv.err = clGetDeviceInfo(cv.device_id, CL_DEVICE_GLOBAL_MEM_SIZE, 			   sizeof(cl_ulong), &mem_size, NULL);  std::cout << "Global mem size: " << mem_size << std::endl;  size_t max_work_item[3];  cv.err = clGetDeviceInfo(cv.device_id, CL_DEVICE_MAX_WORK_ITEM_SIZES, 			   sizeof(max_work_item), max_work_item, NULL);  std::cout << "Max work item sizes: " 	    << max_work_item[0] << ", " 	    << max_work_item[1] << ", " 	    << max_work_item[2] 	    << std::endl;#endif}

/* ...buffer allocation from frontal camera (object detection engine) */static int objdet_input_alloc(void *data, GstBuffer *buffer){    app_data_t         *app = data;    vsink_meta_t       *vmeta = gst_buffer_get_vsink_meta(buffer);    int                 w = vmeta->width, h = vmeta->height;    objdet_meta_t      *ometa;    if (app->f_width)    {        /* ...verify buffer dimensions are valid */        CHK_ERR(w == app->f_width && h == app->f_height, -EINVAL);    }    else    {        int     W = window_get_width(app->window);        int     H = window_get_height(app->window);        /* ...check dimensions are valid */        CHK_ERR(w && h, -EINVAL);        /* ...set buffer dimensions */        app->f_width = w, app->f_height = h;        /* ...initialize object detection engine */        CHK_ERR(app->od = objdet_engine_init(&objdet_callback, app, w, h, __pixfmt_yuv_bpp(vmeta->format), app->od_cfg), -errno);        /* ...create a viewport for data visualization */        texture_scale_to_window(&app->view, app->window, w, h, &app->matrix);                //texture_set_view_scale(&app->view, 0, 0, W, H, W, H, w, h);        /* ...create transformation matrix */        if (0)        {            cairo_matrix_t     *m = &app->matrix;                        m->xx = (double) W / w, m->xy = 0, m->x0 = 0;            m->yx = 0, m->yy = (double) H / h, m->y0 = 0;        }            }    /* ...allocate texture to wrap the buffer */    CHK_ERR(vmeta->priv = texture_create(w, h, vmeta->plane, vmeta->format), -errno);    /* ...add custom buffer metadata */    CHK_ERR(ometa = gst_buffer_add_objdet_meta(buffer), -(errno = ENOMEM));    CHK_ERR(ometa->buf = texture_map(vmeta->priv, CL_MEM_READ_ONLY), -errno);    GST_META_FLAG_SET(ometa, GST_META_FLAG_POOLED);    /* ...add custom destructor to the buffer */    gst_mini_object_weak_ref(GST_MINI_OBJECT(buffer), __destroy_od_texture, app);    TRACE(INFO, _b("front-camera input buffer %p allocated (%p)"), buffer, ometa->buf);    return 0;}

void ArrayOperand::callUp(cl_vars_t clv){  Array * v = dynamic_cast<Array*>(variable);  // For each device  for(int devId = 0 ; devId < partition.nd ; devId++)  {    ssize_t device_min = 0;    ssize_t device_max = 0;    if(partition.d == 0)    {      device_min = 0;      device_max = v->getDim();    }    else    {      device_min = partition.d * devId;      device_max = partition.d * (devId+1);      device_max = (device_max > v->getDim()) ? v->getDim() : device_max;    }    ssize_t device_range = device_max - device_min;    ssize_t bytes_range = device_range * v->bytes_per_element;    ssize_t bytes_offset = device_min * v->bytes_per_element;    if(bytes_range > 0)    {#ifdef VERBOSE_EXECUTION      docs.execution_ss << "TRANSFER: Calling up variable: " << variable->properties["name"];      docs.execution_ss << "/tnbytes: " << bytes_range;      docs.execution_ss << "/tbytes_offset: " << bytes_offset;      docs.execution_ss << "/tdevice id: " << devId << std::endl;#endif      cl_int err = CL_SUCCESS;#ifdef PROFILE      transfer_prof_t tp;      tp.devId = devId;      tp.variable = variable;      err = clEnqueueWriteBuffer(clv.commands[devId], v->gpu_data[devId], CL_FALSE,           		  bytes_offset, bytes_range, v->cpu_data + bytes_offset, 0, NULL, &(tp.event));      transfer_events.push_back(tp);#else      err = clEnqueueWriteBuffer(clv.commands[devId], v->gpu_data[devId], CL_FALSE,           		  bytes_offset, bytes_range, v->cpu_data + bytes_offset, 0, NULL, NULL);#endif      CHK_ERR(err);    }  }}

void* DLLEXPORT PowerMeter_RecallState_ByName( int hInstrumentHandle , char *pszName ) {	STD_ERROR					StdError					=	{0};		int							iStateNumber				=	0;		if ( pszName )		iStateNumber = atoi( pszName );		CHK_ERR(  age441x_loadFromRegister( hInstrumentHandle , iStateNumber ));  	Error:			RETURN_STDERR_POINTER;}

void* DLLEXPORT PowerMeter_FetchPower( int hInstrumentHandle , int iChannel , double timeout , double *value ){	STD_ERROR					StdError					=	{0};		double			 			lfPower						=	0;		CHK_ERR(  age441x_fetch ( hInstrumentHandle , 1 , AGE441X_MEAS_SINGLE , &lfPower ));		if ( value )		*value = lfPower;		Error:			RETURN_STDERR_POINTER;}

void* DLLEXPORT SpectrumAnalyzer_PhaseNoise_GetMarker ( ViSession viInstrumentHandle , int channel , int marker , double *pPosition , double *pValue ){	STD_ERROR               StdError                    =   {0};     		double					lfFrequency					=	0.0,							lfPower						=	0.0;		CHK_ERR( hp8563e_confMkr( viInstrumentHandle , VI_ON , VI_OFF ));			CHK_ERR( hp8563e_perfmSwp ( viInstrumentHandle ));		CHK_ERR( hp8563e_queryAmpl( viInstrumentHandle , 0 , &lfPower )); 	CHK_ERR( hp8563e_queryFreq( viInstrumentHandle , 1 , &lfFrequency )); 	if ( pPosition )		*pPosition = lfFrequency;		if ( pValue )		*pValue = lfPower;	Error: 		RETURN_STDERR_POINTER;}

    int setGlobalOffsets()      {        //only set the global offsets once.        if (setGlobalOffsets_) return(0);        if (matrixGraph_.get() == NULL) return(-1);        MPI_Comm comm = matrixGraph_->getRowSpace()->getCommunicator();        int num_procs = fei::numProcs(comm);        int local_proc = fei::localProc(comm);        std::vector<int> globalOffsets;        std::vector<int> globalBlkOffsets;        if (reducer_.get() != NULL) {          int localsize = reducer_->getLocalReducedEqns().size();          numLocalEqns_ = localsize;          std::vector<int> lsizes(num_procs, 0);          std::vector<int> gsizes(num_procs, 0);          lsizes[local_proc] = localsize;          fei::GlobalMax(comm, lsizes, gsizes);          globalOffsets.resize(num_procs+1);          int offset = 0;          for(int p=0; p<num_procs; ++p) {            globalOffsets[p] = offset;            offset += gsizes[p];          }          globalOffsets[num_procs] = offset;          globalBlkOffsets = globalOffsets;        }        else {          fei::SharedPtr<fei::VectorSpace> vecSpace =             matrixGraph_->getRowSpace();          vecSpace->getGlobalIndexOffsets(globalOffsets);          vecSpace->getGlobalBlkIndexOffsets(globalBlkOffsets);          numLocalEqns_ = globalOffsets[local_proc+1]-globalOffsets[local_proc];        }        CHK_ERR(linsyscore_->setGlobalOffsets(num_procs+1,                                              &globalBlkOffsets[0],                                              &globalOffsets[0],                                              &globalBlkOffsets[0]));        setGlobalOffsets_ = true;        return(0);      }

void* DLLEXPORT SpectrumAnalyzer_GetErrorTextMessage ( ViSession vhInstrumentHandle , int iError , char *pErrorMessage ){	STD_ERROR				StdError					=	{0};    	FREE_CALLOC( StdError.pszErrorDescription , STD_STRING , sizeof(char*));					if ( StdError.pszErrorDescription )			{		CHK_ERR( hp8563e_errorMessage ( vhInstrumentHandle , iError ,(char*)StdError.pszErrorDescription ));	}	Error: 		RETURN_STDERR_POINTER;}

//----------------------------------------------------------------------------int snl_fei::LinearSystem_General::setBCValuesOnVector(fei::Vector* vector){  if (essBCvalues_ == NULL) {    return(0);  }  if (essBCvalues_->size() == 0) {    return(0);  }  CHK_ERR( vector->copyIn(essBCvalues_->size(),			  &(essBCvalues_->indices())[0],			  &(essBCvalues_->coefs())[0]) );  return(0);}

ckError ckOpLimitRule_CreateSliding(ckOpLimitRule** ruleOut, int allowed, ckTime window, ckBool wait){    ckError err = cke_General;        CHK_ERR( allocRule(ruleOut) );    (*ruleOut)->allowedCount = allowed;    (*ruleOut)->waitForSuccess = wait;    (*ruleOut)->type = olrt_SlidingWindow;    (*ruleOut)->data.sliding.window = window;        err = cke_Success;    error:    return err;}

void Array::allocate(cl_vars_t clv){  size_t dim0 = MYMAX(get_property_int("dim0"), 1);  size_t dim1 = MYMAX(get_property_int("dim1"), 1);  bytes_per_element = get_num_bytes(properties["dtype"]);  nbytes = dim0 * dim1 * bytes_per_element;#ifdef VERBOSE_COMPILATION  docs.compilation_ss << "Allocating: " << nbytes << "/tFor array: " << properties["name"] << std::endl; #endif  cpu_data = (char *) calloc(nbytes, sizeof(char));  for(int i = 0 ; i < clv.num_devices ; i++)  {    cl_int err;    gpu_data[i] = clCreateBuffer(clv.context, CL_MEM_READ_WRITE, nbytes, NULL, &err);    CHK_ERR(err);  }}

int fei::Vector_core::writeToFile(const char* filename,                                    bool matrixMarketFormat){  int numProcs = fei::numProcs(comm_);  int localProc =fei::localProc(comm_);  double coef;  static char mmbanner[] = "%%MatrixMarket matrix array real general";  for(int p=0; p<numProcs; ++p) {    fei::Barrier(comm_);    if (p != localProc) continue;    FEI_OFSTREAM* outFile = NULL;    if (p==0) {      outFile = new FEI_OFSTREAM(filename, IOS_OUT);      FEI_OFSTREAM& ofref = *outFile;      if (matrixMarketFormat) {        ofref << mmbanner << FEI_ENDL;        ofref << eqnComm_->getGlobalOffsets()[numProcs] << " 1" << FEI_ENDL;      }      else {        ofref << eqnComm_->getGlobalOffsets()[numProcs] << FEI_ENDL;      }    }    else outFile = new FEI_OFSTREAM(filename, IOS_APP);    FEI_OFSTREAM& ofref = *outFile;    ofref.setf(IOS_SCIENTIFIC, IOS_FLOATFIELD);    ofref.precision(13);    for(int i=firstLocalOffset_; i<=lastLocalOffset_; ++i) {      CHK_ERR( copyOut(1, &i, &coef) );      if (matrixMarketFormat) {        ofref << " " << coef << FEI_ENDL;      }      else {        ofref << i << " " << coef << FEI_ENDL;      }    }        delete outFile;  }       return(0);}

//==============================================================================int load_BC_data(FEI* fei, PoissonData& poissonData){  //first, have the data object generate the BC data  poissonData.calculateBCs();  int numBCNodes = poissonData.getNumBCNodes();  GlobalID* nodeIDs = poissonData.getBCNodeIDs();  int fieldID = poissonData.getBCFieldID();  double* values = poissonData.getBCValues();  std::vector<int> offsets(numBCNodes, 0);  CHK_ERR( fei->loadNodeBCs(numBCNodes, nodeIDs, fieldID,			    &offsets[0], values) );  return(0);}

intDirichletBCManager::finalizeBCEqns(EqnBuffer& bcEqns){  //copy the boundary-condition prescribed values into bcEqns.  bc_map::iterator iter = bcs_.begin(), iter_end = bcs_.end();  for(; iter!=iter_end; ++iter) {    int eqn = iter->first;    double coef = iter->second;    CHK_ERR( bcEqns.addEqn(eqn, &coef, &eqn, 1, false) );  }  bcs_.clear();  return(0);}

ckError ckOpLimitRule_CreateBucket(ckOpLimitRule** ruleOut, int allowed, ckTime length, ckTime epoch, ckBool wait){    ckError err = cke_General;        CHK_ERR( allocRule(ruleOut) );        (*ruleOut)->allowedCount = allowed;    (*ruleOut)->waitForSuccess = wait;        (*ruleOut)->type = olrt_Buckets;    (*ruleOut)->data.bucket.length = length;    (*ruleOut)->data.bucket.epoch = epoch;        err = cke_Success;    error:    return err;}

void* DLLEXPORT PowerMeter_FetchPower( int hInstrumentHandle , int iChannel , double timeout , double *value ){	errEV					ret					=	{0};	errEV					*pRet				=	NULL;		double			 		lfPower				=	0;		CHK_ERR(  age441x_fetch ( hInstrumentHandle , 2 , AGE441X_MEAS_SINGLE , &lfPower ));		if ( value )		*value = lfPower;		Error:			CALLOC_COPY(pRet,1,sizeof(errEV),&ret,sizeof(errEV));		return ((void*)pRet);}

//------------------------------------------------------------------------------int NodeCommMgr::getSendMessage(int destProc, std::vector<int>& message){  std::vector<int>::iterator   rs_iter = std::lower_bound(remoteSharingProcs_.begin(),                              remoteSharingProcs_.end(), destProc);  if (rs_iter == remoteSharingProcs_.end() || destProc != *rs_iter) {    ERReturn(-1);  }  int idx = rs_iter - remoteSharingProcs_.begin();  int len = 0;  CHK_ERR( getSendMessageLength(destProc, len) );  message.resize(len);  packLocalNodesAndData(&message[0], destProc,			nodesPerSharingProc_[idx], len);  return(0);}

int test_Algebraic::runtests(){  if (numProcs_ < 2) {    CHK_ERR( serialtest1() );    CHK_ERR( serialtest2() );  }  CHK_ERR( test1() );  CHK_ERR( test2() );  CHK_ERR( test3() );  CHK_ERR( test4() );  return(0);}

void runKernel(cl_vars_t cv,            cl_kernel cl_kern,            kernel kern,            std::map<std::string, cl_mem_data> gpu_data,            double* vars){    int num_arrays = kern.num_arrays;    string* arrays = kern.arrays;    int num_vars = kern.num_vars;    cl_int err = CL_SUCCESS;    //set up the out array    err = clSetKernelArg(cl_kern, 0, sizeof(cl_mem), &(gpu_data["out"].array));    CHK_ERR(err);    err = clSetKernelArg(cl_kern, 0 + num_arrays, sizeof(int), &(gpu_data["out"].len));    CHK_ERR(err);     for (int i = 1; i < num_arrays; i++)    {        std::string array_name = arrays[i];        err = clSetKernelArg(cl_kern, i, sizeof(cl_mem), &(gpu_data[array_name].array));        CHK_ERR(err);        err = clSetKernelArg(cl_kern, i + num_arrays, sizeof(int), &(gpu_data[array_name].len));        CHK_ERR(err);    }    for (int i = 0; i < num_vars; i++)    {        err = clSetKernelArg(cl_kern, i + 2*num_arrays, sizeof(double), &(vars[i]));        CHK_ERR(err);     }    size_t global_work_size[1] = {gpu_data[arrays[0]].len};    size_t local_work_size[1] = {256};     adjustWorkSize(global_work_size[0], local_work_size[0]);//pad work groups    global_work_size[0] = std::max(local_work_size[0], global_work_size[0]);    err = clEnqueueNDRangeKernel(cv.commands,                                 cl_kern,                                 1,                                 NULL,                                 global_work_size,                                 local_work_size,                                 0,                                 NULL,                                 NULL                                );    CHK_ERR(err);}

int test_MatrixGraph::runtests(){  if (numProcs_ < 2) {    CHK_ERR( serialtest1() );  }  CHK_ERR( test1() );  CHK_ERR( test2() );  CHK_ERR( test3() );  CHK_ERR( test4() );  CHK_ERR( test5() );  CHK_ERR( test_MatrixGraph_test6(comm_, numProcs_, localProc_, path_) );  test_MatrixGraph_test7(comm_, numProcs_, localProc_);  test_MatrixGraph_test8(comm_, numProcs_, localProc_);  return(0);}

/* ...set frontal camera interface */int objdet_camera_init(app_data_t *app, camera_init_func_t camera_init){    GstElement     *bin;    /* ...clear input stream dimensions (force engine reinitialization) */    app->f_width = app->f_height = 0;    /* ...create camera interface (it may be network camera or file on disk) */    CHK_ERR(bin = camera_init(&objdet_camera_cb, app), -errno);    /* ...add camera to a pipe */    gst_bin_add(GST_BIN(app->pipe), bin);    /* ...synchronize state with a parent */    gst_element_sync_state_with_parent(bin);    /* ...save camera-set container */    app->fr_camera = bin;    TRACE(INIT, _b("frontal camera initialized"));    return 0;}

int fei::Vector_core::copyOut(int numValues,				  const int* indices,				  double* values,				  int vectorIndex) const{  const std::vector<CSVec*>& remote = remotelyOwned();  for(int i=0; i<numValues; ++i) {    int ind = indices[i];    int local = ind - firstLocalOffset_;    if (local < 0 || local >= numLocal_) {      if (ind < 0) {	continue;      }      int proc = eqnComm_->getOwnerProc(ind);      int insertPoint = -1;      int idx = fei::binarySearch(ind, remote[proc]->indices(), insertPoint);      if (idx < 0) {	FEI_CERR << "fei::Vector_core::copyOut: proc " << fei::localProc(comm_)	     << ", index " << ind << " not in remotelyOwned_ vec object for proc "            <<proc<<FEI_ENDL;	ERReturn(-1);      }      else {	values[i] = remote[proc]->coefs()[idx];      }    }    else {      CHK_ERR( copyOutOfUnderlyingVector(1, &ind, &(values[i]), vectorIndex) );    }  }  return(0);}

void compile_ocl_program(std::map<std::string, cl_kernel> &kernels, 			 cl_vars_t &cv, const char * cl_src, 			 std::list<std::string> knames){  cl_int err;  cv.main_program = clCreateProgramWithSource(cv.context, 1, (const char **) &cl_src, 					      NULL, &err);  CHK_ERR(err);  err = clBuildProgram(cv.main_program, 0, NULL, NULL, NULL, NULL);  if (err != CL_SUCCESS)    {      size_t len;      char buffer[2048];      std::cout << "Error: Failed to build program executable " << std::endl;      clGetProgramBuildInfo(cv.main_program, cv.device_id, CL_PROGRAM_BUILD_LOG, sizeof(buffer), buffer, &len);      std::cout << buffer << std::endl;      exit(1);    }    for(std::list<std::string>::iterator it = knames.begin(); it != knames.end(); it++)    {      cl_kernel kernel = clCreateKernel(cv.main_program, (*it).c_str(), &(err));      if(!kernel || err != CL_SUCCESS)	{	  std::cout << "Failed to create kernel: " << (*it).c_str()  << std::endl;	  exit(1);	}#ifdef DEBUG      std::cout << "Successfully compiled " << (*it).c_str() << std::endl;#endif      cv.kernels.push_back(kernel);      kernels[*it] = kernel;    }}

void* DLLEXPORT PowerMeter_SetActiveChannel( int hInstrumentHandle , int iChannel ){	STD_ERROR					StdError					=	{0};		switch(iChannel)	{		case 1:				iChannel = AGE441X_CHANNEL_A;				break;		case 2:				iChannel = AGE441X_CHANNEL_B;				break;						default:				iChannel = AGE441X_CHANNEL_A;				break;	}		CHK_ERR( age441x_configureInput ( hInstrumentHandle , iChannel, 50.0E+6, AGE441X_MEAS_DOUBLE ));	Error:			RETURN_STDERR_POINTER;  }

void* DLLEXPORT PowerMeter_MeasurePower( int hInstrumentHandle , int iChannel , double timeout , double *value ){	errEV					ret					=	{0};	errEV					*pRet				=	NULL;		double			 		lfPower				=	0;		ViBoolean				bLimit				=	0;		switch(iChannel)	{		case 1:				iChannel = AGE441X_CHANNEL_A;				break;		case 2:				iChannel = AGE441X_CHANNEL_B;				break;						default:				iChannel = AGE441X_CHANNEL_A;				break;	}			CHK_ERR(  age441x_powerMeasurement ( hInstrumentHandle , iChannel , AGE441X_UNIT_DBM , -90.0, 90.0 , &bLimit , &lfPower ));	if ( value )		*value = lfPower;		//CHK_ERR(  age441x_setInitiateContinuousState ( hInstrumentHandle , iChannel , VI_TRUE ));	Error:			CALLOC_COPY(pRet,1,sizeof(errEV),&ret,sizeof(errEV));		return ((void*)pRet);}

void* DLLEXPORT PowerMeter_SetFrequency( int hInstrumentHandle , int iChannel , double dFreq ){	STD_ERROR					StdError					=	{0};		switch(iChannel)	{		case 1:				iChannel = AGE441X_CHANNEL_A;				break;		case 2:				iChannel = AGE441X_CHANNEL_B;				break;						default:				iChannel = AGE441X_CHANNEL_A;				break;	}			  	CHK_ERR(  age441x_configureFrequency ( hInstrumentHandle , iChannel , dFreq ));	Error:			RETURN_STDERR_POINTER;}

void* DLLEXPORT PowerMeter_InitSweep( int hInstrumentHandle , int iChannel ) {	STD_ERROR					StdError					=	{0};		switch(iChannel)	{		case 1:				iChannel = AGE441X_CHANNEL_A;				break;		case 2:				iChannel = AGE441X_CHANNEL_B;				break;						default:				iChannel = AGE441X_CHANNEL_A;				break;	}			CHK_ERR(  age441x_initiate ( hInstrumentHandle , iChannel ));	Error:			RETURN_STDERR_POINTER;}

void* DLLEXPORT PowerMeter_SetSingleSweep( int hInstrumentHandle , int iChannel ){	STD_ERROR					StdError					=	{0};		switch(iChannel)	{		case 1:				iChannel = AGE441X_CHANNEL_A;				break;		case 2:				iChannel = AGE441X_CHANNEL_B;				break;						default:				iChannel = AGE441X_CHANNEL_A;				break;	}			CHK_ERR(  age441x_setInitiateContinuousState ( hInstrumentHandle , iChannel , VI_FALSE ));	Error:			RETURN_STDERR_POINTER;}