C++ errcheck函数代码示例

int room_goto_previous()
{
    enigma::roomstruct *rit = enigma::roomdata[(int)room.rval.d];
    errcheck((int)room.rval.d,"Going to next room from invalid room. wat");

    rit = enigma::roomorder[rit->order - 1];
    errcheck(rit->order-1,"Going to next room after last");

    rit->gotome();
    return 0;
}

int room_goto_previous()
{
    enigma::roomstruct *rit = enigma::roomdata[(int)room.rval.d];
    errcheck((int)room.rval.d,"Going to next room from invalid room. wat", 0);

    rit = enigma::roomorder[rit->order - 1];
    errcheck(rit->order-1,"Going to next room after last", 0);

    enigma::room_switching_id = rit->id;
    enigma::room_switching_restartgame = false;
    return 1;
}

Object cuda_over_map(Object self, int nparts, int *argcv,
        Object *argv, int flags) {
    CUresult error;
    cuInit(0);
    int deviceCount = 0;
    error = cuDeviceGetCount(&deviceCount);
    if (deviceCount == 0) {
        raiseError("No CUDA devices found");
    }
    CUdevice cuDevice;
    CUcontext cuContext;
    CUmodule cuModule;
    CUfunction cuFunc;
    error = cuDeviceGet(&cuDevice, 0);
    error = cuCtxCreate(&cuContext, 0, cuDevice);
    CUdeviceptr d_A;
    CUdeviceptr d_B;
    CUdeviceptr d_res;
    errcheck(cuModuleLoad(&cuModule, grcstring(argv[argcv[0]])));
    CUdeviceptr dps[argcv[0]];
    void *args[argcv[0]+2];
    int size = INT_MAX;
    for (int i=0; i<argcv[0]; i++) {
        struct CudaFloatArray *a = (struct CudaFloatArray *)argv[i];
        if (a->size < size)
            size = a->size;
        errcheck(cuMemAlloc(&dps[i], size * sizeof(float)));
        errcheck(cuMemcpyHtoD(dps[i], &a->data, size * sizeof(float)));
        args[i+1] = &dps[i];
    }
    struct CudaFloatArray *r =
        (struct CudaFloatArray *)(alloc_CudaFloatArray(size));
    int fsize = sizeof(float) * size;
    errcheck(cuMemAlloc(&d_res, fsize));
    errcheck(cuMemcpyHtoD(d_res, &r->data, fsize));
    args[0] = &d_res;
    args[argcv[0]+1] = &size;

    int threadsPerBlock = 256;
    int blocksPerGrid = (size + threadsPerBlock - 1) / threadsPerBlock;
    char name[256];
    strcpy(name, "block");
    strcat(name, grcstring(argv[argcv[0]]) + strlen("_cuda/"));
    for (int i=0; name[i] != 0; i++)
        if (name[i] == '.') {
            name[i] = 0;
            break;
        }
    errcheck(cuModuleGetFunction(&cuFunc, cuModule, name));
    errcheck(cuLaunchKernel(cuFunc, blocksPerGrid, 1, 1,
        threadsPerBlock, 1, 1,
        0,
        NULL, args, NULL));
    errcheck(cuMemcpyDtoH(&r->data, d_res, fsize));
    cuMemFree(d_res);
    for (int i=0; i<argcv[0]; i++)
        cuMemFree(dps[i]);
    return (Object)r;
}

int room_goto(int indx)
{
  errcheck(indx,"Attempting to go to nonexisting room", 0);
  enigma::room_switching_id = indx;
  enigma::room_switching_restartgame = false;
  return 1;
}

void THInit()
{
	static int init;

	if(init)
		return;
	init_yuv2rgb();
#ifndef USEBLAS
	blas_init();
#endif
	init = 1;
#if defined CUDNN && defined USECUDAHOSTALLOC
	// cuda_maphostmem = 1 requires that memory was allocated with cudaHostAlloc
	// cuda_maphostmem = 2 will work with malloc, but Tegra TX1 does not support cudaHostRegister with cudaHostRegisterMapped
	struct cudaDeviceProp prop;

	cudaGetDeviceProperties(&prop, 0);
	if(prop.canMapHostMemory)
	{
		errcheck(cudaSetDeviceFlags(cudaDeviceMapHost));
		cuda_maphostmem = 1;
	}
#endif
#ifdef OPENCL
	thopencl_init();
#endif
}

int room_restart()
{
	int indx=(int)room.rval.d;
	errcheck(indx,"Is this some kind of joke?");
	enigma::roomdata[indx]->gotome();
	return 0;
}

int room_tile_add_ext(int indx, int bck, int left, int top, int width, int height, int x, int y, int depth, int xscale, int yscale, double alpha, int color)
{
    errcheck(indx,"Nonexistent room", 0);
    enigma::roomstruct *rm = enigma::roomdata[indx];
    const int tcount = rm->tilecount++;
    enigma::tile *ti = rm->tiles;
    enigma::tile *newtiles = new enigma::tile[tcount + 1];
    for (int tilei = 0; tilei < tcount; tilei++)
        newtiles[tilei] = ti[tilei];

    newtiles[tcount].id = enigma::maxtileid++;
    newtiles[tcount].bckid = bck;
    newtiles[tcount].bgx = left;
    newtiles[tcount].bgy = top;
    newtiles[tcount].depth = depth;
    newtiles[tcount].height = height;
    newtiles[tcount].width = width;
    newtiles[tcount].roomX = x;
    newtiles[tcount].roomY = y;
    newtiles[tcount].xscale = xscale;
    newtiles[tcount].yscale = yscale;
    newtiles[tcount].alpha = alpha;
    newtiles[tcount].color = color;

    if (enigma::tile_alter) delete[] rm->tiles;
    rm->tiles = newtiles;
    enigma::tile_alter = true;
    return 1;
}

int room_set_background_color(int indx, int col, bool show)
{
    errcheck(indx,"Nonexistent room", 0);
    enigma::roomdata[indx]->backcolor = col;
    enigma::roomdata[indx]->drawbackcolor = show;
    return 1;
}

int room_restart()
{
  int indx=(int)room.rval.d;
  errcheck(indx, "Is this some kind of joke?", 0);
  enigma::room_switching_id = indx;
  enigma::room_switching_restartgame = false;
  return 1;
}

THFloatTensor *cudnn_Threshold_updateOutput(struct module *module, THFloatTensor *input)
{
	THFloatTensor *output = module->output;
	cudnnTensorDescriptor_t dinput, doutput;
	int inplace = module->Threshold.inplace;
	float one = 1, zero = 0;

	errcheck(THcudnn_TensorDescriptor(&dinput, input));
	if(inplace)
		THFloatTensor_set(output, input);
	else THCudaTensor_resize4d(output, input->size[0], input->size[1], input->size[2], input->size[3]);
	errcheck(THcudnn_TensorDescriptor(&doutput, output));

	errcheck(cudnnActivationForward(THcudnn_getHandle(), CUDNN_ACTIVATION_RELU, &one, dinput, THFloatTensor_data(input), &zero,
		doutput, THFloatTensor_data(output)));

	cudnnDestroyTensorDescriptor(dinput);
	cudnnDestroyTensorDescriptor(doutput);
	return output;
}

int room_instance_clear(int indx)
{
    errcheck(indx,"Nonexistent room", 0);
    enigma::roomstruct *rm = enigma::roomdata[indx];
    enigma::inst *newinst = new enigma::inst[1];
    rm->instancecount = 0;

    if (enigma::instance_alter) delete[] rm->instances;
    rm->instances = newinst;
    enigma::instance_alter = true;
    return 1;
}

int room_tile_clear(int indx)
{
    errcheck(indx,"Nonexistent room", 0);
    enigma::roomstruct *rm = enigma::roomdata[indx];
    enigma::tile *newtiles = new enigma::tile[1];
    rm->tilecount = 0;

    if (enigma::tile_alter) delete[] rm->tiles;
    rm->tiles = newtiles;
    enigma::tile_alter = true;
    return 1;
}

THFloatTensor *cudnn_SpatialMaxPooling_updateOutput(struct module *module, THFloatTensor *input)
{
	int kW = module->SpatialMaxPooling.kW;
	int kH = module->SpatialMaxPooling.kH;
	int dW = module->SpatialMaxPooling.dW;
	int dH = module->SpatialMaxPooling.dH;
	int padW = module->SpatialMaxPooling.padW;
	int padH = module->SpatialMaxPooling.padH;

	THFloatTensor *output = module->output;
	cudnnTensorDescriptor_t dinput, doutput;
	cudnnPoolingDescriptor_t dpool;
	float one = 1, zero = 0;
	int sizes[4];

	errcheck(THcudnn_TensorDescriptor(&dinput, input));
	errcheck(cudnnCreatePoolingDescriptor(&dpool));
	errcheck(cudnnSetPooling2dDescriptor(dpool, CUDNN_POOLING_MAX, kH, kW, padH, padW, dH, dW));
	errcheck(cudnnGetPoolingNdForwardOutputDim(dpool, dinput, 4, sizes));
	THCudaTensor_resize4d(output, sizes[0], sizes[1], sizes[2], sizes[3]);
	errcheck(THcudnn_TensorDescriptor(&doutput, output));

	errcheck(cudnnPoolingForward(THcudnn_getHandle(), dpool, &one, dinput, THFloatTensor_data(input), &zero,
		doutput, THFloatTensor_data(output)));

	cudnnDestroyTensorDescriptor(dinput);
	cudnnDestroyTensorDescriptor(doutput);
	cudnnDestroyPoolingDescriptor(dpool);
	return output;
}

int main(int argc, char* argv[])
{
  if (argc !=4)
    usage();
  string hostsFile=argv[1];
  ifstream diff(argv[2]);
  port = (unsigned short)atoi(argv[3]);
  if (diff.fail()) {
    cerr << "error: open diff file" << endl;
    usage();
  }
  if (verbose) cout << "Reading diff..." << endl;
  assert(readChanges(diff));
  if (verbose) cout << "Reading core info..." << endl;
  assert(getCores(hostsFile));
  diff.close();
  if (verbose) cout << "Getting addresses..."<<endl;
  errcheck(getAddrs());
  if (verbose) cout << "Constructing stage data..."<<endl;
  errcheck(makeStages());
  if (verbose) cout << "Opening connections..." << endl;
  errcheck(initConnections());
  
  if (verbose) cout << "Transferring stage data..." << endl;
  errcheck(sendStages());
  int i;
  for (i=0;i<3;i++) {
    if (verbose) cout << "Doing stage " << i << "..."<<endl;
    errcheck(doStage(i));
  }
  if (verbose) cout << "Closing connections..." <<endl;
  errcheck(finishConnections());
  if (verbose) cout<<"Reassign complete."<<endl;
}

Cell *arith(Node **a, int n)	/* a[0] + a[1], etc.  also -a[0] */
{
	Awkfloat i, j = 0;
	double v;
	Cell *x, *y, *z;

	x = execute(a[0]);
	i = getfval(x);
	tempfree(x);
	if (n != UMINUS) {
		y = execute(a[1]);
		j = getfval(y);
		tempfree(y);
	}
	z = gettemp();
	switch (n) {
	case ADD:
		i += j;
		break;
	case MINUS:
		i -= j;
		break;
	case MULT:
		i *= j;
		break;
	case DIVIDE:
		if (j == 0)
			ERROR "division by zero" FATAL;
		i /= j;
		break;
	case MOD:
		if (j == 0)
			ERROR "division by zero in mod" FATAL;
		modf(i/j, &v);
		i = i - j * v;
		break;
	case UMINUS:
		i = -i;
		break;
	case POWER:
		if (j >= 0 && modf(j, &v) == 0.0)	/* pos integer exponent */
			i = ipow(i, (int) j);
		else
			i = errcheck(pow(i, j), "pow");
		break;
	default:	/* can't happen */
		ERROR "illegal arithmetic operator %d", n FATAL;
	}
	setfval(z, i);
	return(z);
}