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

//convert tensor in MKL layout back to Numpy NCHW layout//if layout diff, do conversion, else, copy memory directlyvoid ConvertBack(unsigned long long tensor_, int N, int C, int H, int W){    long long * tensor = (long long *)tensor_;    if (tensor[CPUPtr] == 0 )    {        printf("error to converback tensor!/n");        return;    }	if (tensor[MKLLayout] == 0)    return;//do not need convert    dnnError_t err;	size_t inSize[DIM4]   =   { W, H, C, N};	size_t inStride[DIM4] =   { 1, W, W*H, W*H*C};	dnnLayout_t lt_NCHW = NULL, lt_CHWN = NULL;	float* newPtr = NULL;	CHECK_ERR( dnnLayoutCreate_F32(&lt_NCHW, DIM4, inSize, inStride),  err );	if (!dnnLayoutCompare_F32((dnnLayout_t)tensor[MKLLayout], (dnnLayout_t)tensor[CPULayout]))	{		float* cpuPtr = (float *)tensor[CPUPtr];		float* mklPtr = (float *)tensor[MKLPtr];		if (!dnnLayoutCompare_F32((dnnLayout_t)tensor[MKLLayout], lt_NCHW))		{		    dnnPrimitive_t cv;            CHECK_ERR( dnnConversionCreate_F32(&cv, (dnnLayout_t)tensor[MKLLayout],lt_NCHW), err );            newPtr = (float*)malloc(N*C*H*W*sizeof(float));            CHECK_ERR( dnnConversionExecute_F32(cv, mklPtr, newPtr), err );            mklPtr = newPtr;		}        mkl_somatcopy('r', 't', N, C*H*W, 1.0, mklPtr, C*H*W, cpuPtr, N);	}	else	{	    long long grad_in_len = (long long)dnnLayoutGetMemorySize_F32((dnnLayout_t)tensor[MKLLayout]) ;        float * destPtr = (float*)tensor[CPUPtr];        float * srcPtr = (float*)tensor[MKLPtr];        #pragma omp parallel for        for (long long i = 0; i < grad_in_len/4; ++i)        {            destPtr[i] = srcPtr[i];        }    }ERR_RETURN:    if (newPtr!=NULL) 	{ 	    free(newPtr); 	}}

static int s5k5bbgx_set_capture_start(struct v4l2_subdev *sd){	struct s5k5bbgx_state *state = to_state(sd);	int err = -EINVAL;	u16 val = 1, retry = 0;	/* set initial regster value */#ifdef CONFIG_LOAD_FILE	err = s5k5bbgx_write_regs_from_sd(sd, "s5k5bbgx_capture");#else	err = s5k5bbgx_write_regs(sd, s5k5bbgx_capture,		sizeof(s5k5bbgx_capture) / sizeof(s5k5bbgx_capture[0]));#endif	if (unlikely(err)) {		cam_err("failed to make capture/n");		return err;	}	s5k5bbgx_get_exif(sd);	cam_info("Capture ConfigSync/n");	do {		msleep(20);		err = s5k5bbgx_read_reg(sd, REG_PAGE_CAPTURE_STATUS, REG_ADDR_CAPTURE_STATUS, &val);		CHECK_ERR(err);		cam_dbg("val = %d/n", val);		if (val == 0)			break;		retry++;	} while (retry <= S5K5BBGX_READ_STATUS_RETRIES);	return err;}

// findvoid buildin_string_find(fake * fk, interpreter * inter){	BIF_CHECK_ARG_NUM(3);	const char * findstr = fkpspopcstrptr(fk);	int pos = fkpspop<int>(fk);	const char * srcstr = 0;	variant * v = 0;	bool err = false;	PS_POP_AND_GET(fk->ps, v);	V_GET_STRING(v, srcstr);	CHECK_ERR(err);		int len = srcstr ? v->data.str->sz : 0;	if (pos >= 0 && pos < len && srcstr && findstr)	{		const char * find = strstr(srcstr + pos, findstr);		if (find)		{			fkpspush<bool>(fk, true);			fkpspush<int>(fk, (int)(find - srcstr));		}		else		{			fkpspush<bool>(fk, false);			fkpspush<int>(fk, -1);		}	}	else	{		fkpspush<bool>(fk, false);		fkpspush<int>(fk, -1);	}}

int main(int argc, char ** argv){  char * recname;  config_t cfg;  if(argc != 2)    usage(argv[0]);    recname = argv[1];    err = open(STATEFILE,O_RDWR);  CHECK_ERR_LTZ("Open schedule file");  fd = err;  err = flock(fd, LOCK_SH);  CHECK_ERR("Lock statefile");  err = atexit(&exitfunc);  config_init(&cfg);  config_read_file(&cfg, STATEFILE);  config_setting_t *root;  root = config_root_setting(&cfg);  err = config_setting_remove(root, recname);  CHECK_CFG("Remove recording from schedule");  err = config_write_file(&cfg, STATEFILE);  CHECK_CFG("Write config file");  config_destroy(&cfg);  return 0;}

/* Thread: main */intlibrary_init(void){  int i;  int ret;  scan_exit = false;  scanning = false;  CHECK_NULL(L_LIB, evbase_lib = event_base_new());  CHECK_NULL(L_LIB, updateev = evtimer_new(evbase_lib, update_trigger_cb, NULL));  for (i = 0; sources[i]; i++)    {      if (!sources[i]->init)	continue;      ret = sources[i]->init();      if (ret < 0)	sources[i]->disabled = 1;    }  CHECK_NULL(L_LIB, cmdbase = commands_base_new(evbase_lib, NULL));  CHECK_ERR(L_LIB, pthread_create(&tid_library, NULL, library, NULL));#if defined(HAVE_PTHREAD_SETNAME_NP)  pthread_setname_np(tid_library, "library");#elif defined(HAVE_PTHREAD_SET_NAME_NP)  pthread_set_name_np(tid_library, "library");#endif  return 0;}

unsigned long Camera::getMaxDataRate(){  tPvUint32 min_data_rate, max_data_rate;  CHECK_ERR( PvAttrRangeUint32(handle_, "StreamBytesPerSecond", &min_data_rate, &max_data_rate),             "Couldn't get range of attribute StreamBytesPerSecond" );  return max_data_rate;}

void cl_select_context(cl_platform_id* platform, cl_device_id* device, cl_context* context) {    cl_int err;#if defined (__APPLE__)    CGLContextObj kCGLContext = CGLGetCurrentContext();    CGLShareGroupObj kCGLShareGroup = CGLGetShareGroup(kCGLContext);    cl_context_properties props[] =    {        CL_CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE, (cl_context_properties)kCGLShareGroup,        0    };    *context = clCreateContext(props, 0,0, NULL, NULL, &err);#else    #ifdef UNIX    cl_context_properties props[] =    {        CL_GL_CONTEXT_KHR, (cl_context_properties)glXGetCurrentContext(),        CL_GLX_DISPLAY_KHR, (cl_context_properties)glXGetCurrentDisplay(),        CL_CONTEXT_PLATFORM, (cl_context_properties)platform,        0    };    *context = clCreateContext(props, 1, &cdDevices[uiDeviceUsed], NULL, NULL, &err);    #else // Win32    cl_context_properties props[] =    {        CL_GL_CONTEXT_KHR, (cl_context_properties)wglGetCurrentContext(),        CL_WGL_HDC_KHR, (cl_context_properties)wglGetCurrentDC(),        CL_CONTEXT_PLATFORM, (cl_context_properties)*platform,        0    };    *context = clCreateContext(props, 1, device, NULL, NULL, &err);    CHECK_ERR(err);#endif#endif}

int main(int argc, char *argv[]){    int rank;    int errors = 0, all_errors = 0;    int buf;    MPI_Win win;    MPI_Init(&argc, &argv);    MPI_Comm_rank(MPI_COMM_WORLD, &rank);    MPI_Win_create(&buf, sizeof(int), sizeof(int), MPI_INFO_NULL, MPI_COMM_WORLD, &win);    MPI_Win_set_errhandler(win, MPI_ERRORS_RETURN);    /* This should fail because the window is not locked. */    CHECK_ERR(MPI_Win_unlock(0, win));    MPI_Win_free(&win);    MPI_Reduce(&errors, &all_errors, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);    if (rank == 0 && all_errors == 0)        printf(" No Errors/n");    MPI_Finalize();    return 0;}

int main(int argc, char *argv[]){    int          rank, nproc;    int          errors = 0, all_errors = 0;    int          buf, my_buf;    MPI_Win      win;    MPI_Init(&argc, &argv);    MPI_Comm_rank(MPI_COMM_WORLD, &rank);    MPI_Comm_size(MPI_COMM_WORLD, &nproc);    MPI_Win_create(&buf, sizeof(int), sizeof(int),                    MPI_INFO_NULL, MPI_COMM_WORLD, &win);    MPI_Win_set_errhandler(win, MPI_ERRORS_RETURN);    MPI_Win_fence(0, win);    MPI_Win_lock(MPI_LOCK_SHARED, 0, MPI_MODE_NOCHECK, win);    MPI_Get(&my_buf, 1, MPI_INT, 0, 0, 1, MPI_INT, win);    MPI_Win_unlock(0, win);    /* This should fail because the window is no longer in a fence epoch */    CHECK_ERR(MPI_Get(&my_buf, 1, MPI_INT, 0, 0, 1, MPI_INT, win));    MPI_Win_fence(0, win);    MPI_Win_free(&win);    MPI_Reduce(&errors, &all_errors, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);    if (rank == 0 && all_errors == 0) printf(" No Errors/n");    MPI_Finalize();    return 0;}

void printMemInfo(const char *header){  int bytesInMb = 1024 * 1024;  int device;  size_t free;  size_t total;  CHECK_ERR(cudaGetDevice(&device));  CHECK_ERR(cudaMemGetInfo(&free, &total));  long freeMb = free / bytesInMb;  long usedMb = (total - free) / bytesInMb;  long totalMb = total / bytesInMb;  printf("--%-50s GPU [%d] Mem Used: %-6ld MB. Free: %-6ld MB. Total: %-6ld MB/n", header, device, usedMb, freeMb,      totalMb);}

int handle_error(struct recording_entity *re, int errornum){  int err = 0;  struct common_io_info *ioi = (struct common_io_info *)re->opt;  if (errornum == ENOSPC)    {      E("Mount point full. Setting to read only");      //TODO: Augment infra for read only nodes      //Remember to not remove straight from branch      ioi->status = RECSTATUS_FULL;      set_free(ioi->opt->diskbranch, re->self);    }  else    {      E("Writer broken");      /* Done in close */      ioi->opt->hd_failures++;      if (ioi->opt->optbits & READMODE)        {          afi_mark_recid_missing(ioi->opt->filename, ioi->id);        }      remove_from_branch(ioi->opt->diskbranch, re->self, 0);      err = re->close(re, NULL);      CHECK_ERR("Close faulty recer");      /* TODO:  Need to solve this free-stuff! */      //free(re);      //be->recer->close(be->recer,NULL);      D("Closed recer");    }  return err;}

int common_writecfg(struct recording_entity *re, void *opti){  int err;  struct common_io_info *ioi = re->opt;  struct opt_s *opt = opti;  char *cfgname = (char *)malloc(sizeof(char) * FILENAME_MAX);  char *dirname = (char *)malloc(sizeof(char) * FILENAME_MAX);  CHECK_ERR_NONNULL(cfgname, "Malloc cfgname");  CHECK_ERR_NONNULL(dirname, "Malloc dirname");  struct stat sb;  sprintf(dirname, "%s%i%s%s", ROOTDIRS, ioi->id, "/", opt->filename);  if (stat(dirname, &sb) != 0)    {      //perror("Error Opening dir");      //ERR_IN_INIT;      D("The dir %s doesn't exist. Probably no files written to it. Returning ok", dirname);      free(cfgname);      free(dirname);      return 0;    }  sprintf(cfgname, "%s%i%s%s%s%s%s", ROOTDIRS, ioi->id, "/", opt->filename,          "/", opt->filename, ".cfg");  err = write_cfg_for_rec(opt, cfgname);  CHECK_ERR("write cfg for rec");  free(cfgname);  free(dirname);  return err;}

/* * pool_hdr_uuid_fix -- (internal) fix UUID value */static intpool_hdr_uuid_fix(PMEMpoolcheck *ppc, location *loc, uint32_t question,	void *context){	LOG(3, NULL);	ASSERTne(loc, NULL);	switch (question) {	case Q_UUID_SET:		CHECK_INFO(ppc, "%ssetting pool_hdr.uuid to %s", loc->prefix,			check_get_uuid_str(*loc->valid_uuid));		memcpy(loc->hdr.uuid, loc->valid_uuid, POOL_HDR_UUID_LEN);		break;	case Q_UUID_REGENERATE:		if (util_uuid_generate(loc->hdr.uuid) != 0) {			ppc->result = CHECK_RESULT_INTERNAL_ERROR;			return CHECK_ERR(ppc, "%suuid generation failed",				loc->prefix);		}		CHECK_INFO(ppc, "%ssetting pool_hdr.uuid to %s", loc->prefix,			check_get_uuid_str(loc->hdr.uuid));		break;	default:		ERR("not implemented question id: %u", question);	}	return 0;}

intolsrd_mdp_init(co_obj_t *self, co_obj_t **output, co_obj_t *params){  svl_crypto_ctx *ctx = NULL;  CHECK(IS_LIST(params) && co_list_length(params) == 2, "Invalid params");    size_t sid_len = co_str_len(co_list_element(params, 1));  char *sid_str = _LIST_ELEMENT(params, 1);    CHECK(sid_len == (2 * SID_SIZE) + 1 && str_is_subscriber_id(sid_str) == 1, "Invalid SID");    ctx = svl_crypto_ctx_new();    stowSid(ctx->sid, 0, sid_str);    ctx->keyring_path = _LIST_ELEMENT(params, 0);  ctx->keyring_len = co_str_len(co_list_element(params, 0)) - 1;  CHECK_ERR(ctx->keyring_len < PATH_MAX,"Keyring path too long");    CHECK(serval_init_keyring(ctx), "Failed to initialize Serval keyring");    CMD_OUTPUT("key", co_bin8_create((char*)ctx->sas_private, crypto_sign_SECRETKEYBYTES, 0));    return 1;error:  if (ctx)    svl_crypto_ctx_free(ctx);  return 0;}

void Camera::setup(){  // adjust packet size according to the current network capacity  tPvUint32 maxPacketSize = 9000;  PvCaptureAdjustPacketSize(handle_, maxPacketSize);  // set data rate to the max  unsigned long max_data_rate = getMaxDataRate();  if (max_data_rate < GIGE_MAX_DATA_RATE) {    ROS_WARN("Detected max data rate is %lu bytes/s, typical maximum data rate for a "             "GigE port is %lu bytes/s. Are you using a GigE network card and cable?/n",             max_data_rate, GIGE_MAX_DATA_RATE);  }  setAttribute("StreamBytesPerSecond", max_data_rate);  // capture whole frame by default  setBinning();  setRoiToWholeFrame();    // query for attributes (TODO: more)  CHECK_ERR( PvAttrUint32Get(handle_, "TotalBytesPerFrame", &frameSize_),             "Unable to retrieve frame size" );    // allocate frame buffers  frames_ = new tPvFrame[bufferSize_];  memset(frames_, 0, sizeof(tPvFrame) * bufferSize_);  for (unsigned int i = 0; i < bufferSize_; ++i)  {    frames_[i].ImageBuffer = new char[frameSize_];    frames_[i].ImageBufferSize = frameSize_;    frames_[i].Context[0] = (void*)this; // for frameDone callback  }}

static int adu_unlock(struct target *target){	uint64_t val;	CHECK_ERR(read_target(target, ALTD_CMD_REG, &val));	if (!(val & FBC_LOCKED)) {		PR_INFO("ADU already unlocked!/n");		return 0;	}	val &= ~FBC_LOCKED;	CHECK_ERR(write_target(target, ALTD_CMD_REG, val));	return 0;}

static void getStringValuedAttribute(std::string &value,  boost::function<tPvErr (char*, unsigned long, unsigned long*)> get_fn){  if (value.size() == 0)    value.resize(32);  unsigned long actual_size;  CHECK_ERR( get_fn(&value[0], value.size(), &actual_size),             "Couldn't get attribute" );  if (actual_size >= value.size()) {    value.resize(actual_size + 1);    CHECK_ERR( get_fn(&value[0], value.size(), &actual_size),               "Couldn't get attribute" );  }}

/* * backup_poolset_overwrite -- (internal) backup poolset with overwrite */static intbackup_poolset_overwrite(PMEMpoolcheck *ppc, location *loc,	uint32_t question, void *context){	LOG(3, NULL);	ASSERTne(loc, NULL);	switch (question) {	case Q_OVERWRITE_EXISTING_PARTS:		if (backup_poolset(ppc, loc, 1 /* overwrite */)) {			location_release(loc);			ppc->result = CHECK_RESULT_ERROR;			return CHECK_ERR(ppc, "cannot perform backup");		}		location_release(loc);		loc->step = CHECK_STEP_COMPLETE;		return 0;	default:		ERR("not implemented question id: %u", question);	}	return 0;}

/** * Determine if we have a key is known in our local keyring. * @param handle the context handle * @param fpr the fingerprint key ID to look up * @return 1 if key is known, 0 if key is unknown, -1 on error */static int key_in_keychain(alpm_handle_t *handle, const char *fpr){	gpgme_error_t err;	gpgme_ctx_t ctx;	gpgme_key_t key;	int ret = -1;	memset(&ctx, 0, sizeof(ctx));	err = gpgme_new(&ctx);	CHECK_ERR();	_alpm_log(handle, ALPM_LOG_DEBUG, "looking up key %s locally/n", fpr);	err = gpgme_get_key(ctx, fpr, &key, 0);	if(gpg_err_code(err) == GPG_ERR_EOF) {		_alpm_log(handle, ALPM_LOG_DEBUG, "key lookup failed, unknown key/n");		ret = 0;	} else if(gpg_err_code(err) == GPG_ERR_NO_ERROR) {		_alpm_log(handle, ALPM_LOG_DEBUG, "key lookup success, key exists/n");		ret = 1;	} else {		_alpm_log(handle, ALPM_LOG_DEBUG, "gpg error: %s/n", gpgme_strerror(err));	}	gpgme_key_unref(key);error:	gpgme_release(ctx);	return ret;}

static int fsi2pib_getscom(struct pib *pib, uint64_t addr, uint64_t *value){	uint32_t result;	usleep(FSI2PIB_RELAX);	/* Get scom works by putting the address in FSI_CMD_REG and	 * reading the result from FST_DATA[01]_REG. */	CHECK_ERR(fsi_write(&pib->target, FSI_CMD_REG, addr));	CHECK_ERR(fsi_read(&pib->target, FSI_DATA0_REG, &result));	*value = ((uint64_t) result) << 32;	CHECK_ERR(fsi_read(&pib->target, FSI_DATA1_REG, &result));	*value |= result;	return 0;}

/* * sds_check -- (internal) check shutdown_state */static intsds_check(PMEMpoolcheck *ppc, location *loc){	LOG(3, NULL);	CHECK_INFO(ppc, "%s" SDS_CHECK_STR, loc->prefix);	/* shutdown state is valid */	if (!sds_check_replica(loc)) {		CHECK_INFO(ppc, "%s" SDS_OK_STR, loc->prefix);		loc->step = CHECK_STEP_COMPLETE;		return 0;	}	/* shutdown state is NOT valid and can NOT be repaired */	if (CHECK_IS_NOT(ppc, REPAIR)) {		check_end(ppc->data);		ppc->result = CHECK_RESULT_NOT_CONSISTENT;		return CHECK_ERR(ppc, "%s%s", loc->prefix,				SDS_FAIL_MSG(&loc->hdr));	}	/* shutdown state is NOT valid but can be repaired */	CHECK_ASK(ppc, Q_RESET_SDS, "%s%s", loc->prefix,			SDS_REPAIR_MSG(&loc->hdr));	return check_questions_sequence_validate(ppc);}

void DataArchive::WriteEntry(int index, BYTE* buf){   int f = _open(datafile, _O_RDWR|_O_CREAT|_O_BINARY, _S_IREAD|_S_IWRITE);   if (f != -1) {      header.dir_size_comp = DirBlocks() * BLOCK_SIZE;      dirbuf = new BYTE[header.dir_size_comp];      err = compress(dirbuf, &header.dir_size_comp,                      (BYTE*) directory, header.nfiles * sizeof(DataEntry));      CHECK_ERR(err, "compress");      header.dir_blocks = Blocks(header.dir_size_comp) * BLOCK_SIZE;      _lseek(f, 0, SEEK_SET);      _write(f, &header, sizeof(DataHeader));      _lseek(f, sizeof(DataHeader) + header.dir_offset, SEEK_SET);      _write(f, dirbuf, header.dir_blocks);            delete [] dirbuf;            if (buf && directory[index].size_comp) {         _lseek(f, sizeof(DataHeader) + directory[index].offset, SEEK_SET);         _write(f, buf, directory[index].size_comp);      }      _close(f);   }   else      perror("WriteEntry");}

static int s5k5bbgx_debug_sensor_status(struct v4l2_subdev *sd){	u16 val = 0;	int err = -EINVAL;	/* Read Mon_DBG_Counters_2 */	/*err = s5k5bbgx_read_reg(sd, 0x7000, 0x0402, &val);	CHECK_ERR(err);	cam_info("counter = %d/n", val); */	/* Read REG_TC_GP_EnableCaptureChanged. */	err = s5k5bbgx_read_reg(sd, 0x7000, 0x01F6, &val);	CHECK_ERR(err);		switch(val) {	case 0:		cam_info("In normal mode(0)/n");		break;	case 1:		cam_info("In swiching to capture mode(1)...../n");		break;	default:		cam_err("In Unknown mode(?)/n");		break;	}	return 0;}

BYTE* DataArchive::CompressEntry(int i){   char* name = directory[i].name;   FILE* f = fopen(name, "rb");   if (f) {      fseek(f, 0, SEEK_END);      DWORD len = ftell(f);      fseek(f, 0, SEEK_SET);            BYTE* buf = new BYTE[len];            fread(buf, len, 1, f);      fclose(f);      directory[i].size_orig = len;            directory[i].size_comp = (int) (len * 1.1);      BYTE* cbuf = new BYTE[directory[i].size_comp];      err = compress(cbuf, &directory[i].size_comp, buf, len);      CHECK_ERR(err, "compress");            delete [] buf;      return cbuf;   }      return 0;}

int ram_putmsr(struct pdbg_target *thread, uint64_t value){	uint64_t opcodes[] = {mfspr(0, 277), mtmsr(0)};	uint64_t results[] = {value, 0};	CHECK_ERR(ram_instructions(thread, opcodes, results, ARRAY_SIZE(opcodes), 0));	return 0;}

static int fsi2pib_getscom(struct target *target, uint64_t addr, uint64_t *value){	uint64_t result;	usleep(FSI2PIB_RELAX);	/* Get scom works by putting the address in FSI_CMD_REG and	 * reading the result from FST_DATA[01]_REG. */	CHECK_ERR(write_next_target(target, FSI_RESET_REG, FSI_RESET_CMD));	CHECK_ERR(write_next_target(target, FSI_CMD_REG, addr));	CHECK_ERR(read_next_target(target, FSI_DATA0_REG, &result));	*value = result << 32;	CHECK_ERR(read_next_target(target, FSI_DATA1_REG, &result));	*value |= result;	return 0;}

void MaxPooling_fprop(    unsigned long long input,    unsigned long long output,    unsigned long long dnnprimitives,    int initOk,    int useMaxPooling,    int N, int inC,    int inH, int inW,    int kH, int kW,    int dH, int dW,    int padH, int padW,    int outC, int outH, int outW,    int bCeil){    dnnError_t err;    long long* primitives = (long long*)dnnprimitives;     if(initOk == 0)    {        Init_f((long long *)input, (long long *)output, primitives,N, inC, inH, inW, kH, kW, dH, dW, padH, padW, outC, outH, outW, useMaxPooling, bCeil);    }    //get resource    float* resPool[dnnResourceNumber] = {0};     float* input_data = GetPtr(input);    resPool[dnnResourceSrc]       = input_data;    resPool[dnnResourceDst]       = (float*)primitives[BUFFER_POOLING_FORWARD_OUTPUT];    resPool[dnnResourceWorkspace] = (float*)primitives[BUFFER_POOLING_FORWARD_WORKSPACE];    //do input conversion if necessary    dnnPrimitive_t cv_in_f     = (dnnPrimitive_t)primitives[CV_POOLING_FORWARD_INPUT];    if(cv_in_f)    {        float* buf_in_f     = (float*) (primitives[BUFFER_POOLING_FORWARD_INPUT]);        CHECK_ERR( dnnConversionExecute_F32(cv_in_f, input_data, buf_in_f), err );        resPool[dnnResourceSrc] = buf_in_f;    }    CHECK_ERR( dnnExecute_F32((dnnPrimitive_t)primitives[POOLING_FORWARD], (void**)resPool), err );    ((long long*)output)[MKLPtr]    = primitives[BUFFER_POOLING_FORWARD_OUTPUT];    ((long long*)output)[MKLLayout] = primitives[POOL_L_F_O];ERR_RETURN:    return;}