void BaseConvolutionLayer<Dtype>::LayerSetUp(const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) { // Configure the kernel size, padding, stride, and inputs. ConvolutionParameter conv_param = this->layer_param_.convolution_param(); force_nd_im2col_ = conv_param.force_nd_im2col(); channel_axis_ = bottom[0]->CanonicalAxisIndex(conv_param.axis()); const int first_spatial_axis = channel_axis_ + 1; const int num_axes = bottom[0]->num_axes(); num_spatial_axes_ = num_axes - first_spatial_axis; CHECK_GE(num_spatial_axes_, 0); vector<int> bottom_dim_blob_shape(1, num_spatial_axes_ + 1); vector<int> spatial_dim_blob_shape(1, std::max(num_spatial_axes_, 1)); // Setup filter kernel dimensions (kernel_shape_). kernel_shape_.Reshape(spatial_dim_blob_shape); int* kernel_shape_data = kernel_shape_.mutable_cpu_data(); if (conv_param.has_kernel_h() || conv_param.has_kernel_w()) { CHECK_EQ(num_spatial_axes_, 2) << "kernel_h & kernel_w can only be used for 2D convolution."; CHECK_EQ(0, conv_param.kernel_size_size()) << "Either kernel_size or kernel_h/w should be specified; not both."; kernel_shape_data[0] = conv_param.kernel_h(); kernel_shape_data[1] = conv_param.kernel_w(); } else { const int num_kernel_dims = conv_param.kernel_size_size(); CHECK(num_kernel_dims == 1 || num_kernel_dims == num_spatial_axes_) << "kernel_size must be specified once, or once per spatial dimension " << "(kernel_size specified " << num_kernel_dims << " times; " << num_spatial_axes_ << " spatial dims);"; for (int i = 0; i < num_spatial_axes_; ++i) { kernel_shape_data[i] = conv_param.kernel_size((num_kernel_dims == 1) ? 0 : i); } } for (int i = 0; i < num_spatial_axes_; ++i) { CHECK_GT(kernel_shape_data[i], 0) << "Filter dimensions must be nonzero."; } // Setup stride dimensions (stride_). stride_.Reshape(spatial_dim_blob_shape); int* stride_data = stride_.mutable_cpu_data(); if (conv_param.has_stride_h() || conv_param.has_stride_w()) { CHECK_EQ(num_spatial_axes_, 2) << "stride_h & stride_w can only be used for 2D convolution."; CHECK_EQ(0, conv_param.stride_size()) << "Either stride or stride_h/w should be specified; not both."; stride_data[0] = conv_param.stride_h(); stride_data[1] = conv_param.stride_w(); } else { const int num_stride_dims = conv_param.stride_size(); CHECK(num_stride_dims == 0 || num_stride_dims == 1 || num_stride_dims == num_spatial_axes_) << "stride must be specified once, or once per spatial dimension " << "(stride specified " << num_stride_dims << " times; " << num_spatial_axes_ << " spatial dims);"; const int kDefaultStride = 1; for (int i = 0; i < num_spatial_axes_; ++i) { stride_data[i] = (num_stride_dims == 0) ? kDefaultStride : conv_param.stride((num_stride_dims == 1) ? 0 : i); CHECK_GT(stride_data[i], 0) << "Stride dimensions must be nonzero."; } } // Setup pad dimensions (pad_). pad_.Reshape(spatial_dim_blob_shape); int* pad_data = pad_.mutable_cpu_data(); if (conv_param.has_pad_h() || conv_param.has_pad_w()) { CHECK_EQ(num_spatial_axes_, 2) << "pad_h & pad_w can only be used for 2D convolution."; CHECK_EQ(0, conv_param.pad_size()) << "Either pad or pad_h/w should be specified; not both."; pad_data[0] = conv_param.pad_h(); pad_data[1] = conv_param.pad_w(); } else { const int num_pad_dims = conv_param.pad_size(); CHECK(num_pad_dims == 0 || num_pad_dims == 1 || num_pad_dims == num_spatial_axes_) << "pad must be specified once, or once per spatial dimension " << "(pad specified " << num_pad_dims << " times; " << num_spatial_axes_ << " spatial dims);"; const int kDefaultPad = 0; for (int i = 0; i < num_spatial_axes_; ++i) { pad_data[i] = (num_pad_dims == 0) ? kDefaultPad : conv_param.pad((num_pad_dims == 1) ? 0 : i); } } // Special case: im2col is the identity for 1x1 convolution with stride 1 // and no padding, so flag for skipping the buffer and transformation. is_1x1_ = true; for (int i = 0; i < num_spatial_axes_; ++i) { is_1x1_ &= kernel_shape_data[i] == 1 && stride_data[i] == 1 && pad_data[i] == 0; if (!is_1x1_) { break; } } // Configure output channels and groups. channels_ = bottom[0]->shape(channel_axis_); num_output_ = this->layer_param_.convolution_param().num_output(); CHECK_GT(num_output_, 0); group_ = this->layer_param_.convolution_param().group(); CHECK_EQ(channels_ % group_, 0); CHECK_EQ(num_output_ % group_, 0) << "Number of output should be multiples of group."; if (reverse_dimensions()) { conv_out_channels_ = channels_; conv_in_channels_ = num_output_; } else { conv_out_channels_ = num_output_; conv_in_channels_ = channels_; } // Handle the parameters: weights and biases. // - blobs_[0] holds the filter weights // - blobs_[1] holds the biases (optional) vector<int> weight_shape(2); weight_shape[0] = conv_out_channels_; weight_shape[1] = conv_in_channels_ / group_; for (int i = 0; i < num_spatial_axes_; ++i) { weight_shape.push_back(kernel_shape_data[i]); } bias_term_ = this->layer_param_.convolution_param().bias_term(); vector<int> bias_shape(bias_term_, num_output_); if (this->blobs_.size() > 0) { CHECK_EQ(1 + bias_term_, this->blobs_.size()) << "Incorrect number of weight blobs."; if (weight_shape != this->blobs_[0]->shape()) { Blob<Dtype> weight_shaped_blob(weight_shape); LOG(FATAL) << "Incorrect weight shape: expected shape " << weight_shaped_blob.shape_string() << "; instead, shape was " << this->blobs_[0]->shape_string(); } if (bias_term_ && bias_shape != this->blobs_[1]->shape()) { Blob<Dtype> bias_shaped_blob(bias_shape); LOG(FATAL) << "Incorrect bias shape: expected shape " << bias_shaped_blob.shape_string() << "; instead, shape was " << this->blobs_[1]->shape_string(); } LOG(INFO) << "Skipping parameter initialization"; } else { if (bias_term_) { this->blobs_.resize(2); } else { this->blobs_.resize(1); } // Initialize and fill the weights: // output channels x input channels per-group x kernel height x kernel width this->blobs_[0].reset(new Blob<Dtype>(weight_shape)); shared_ptr<Filler<Dtype> > weight_filler(GetFiller<Dtype>( this->layer_param_.convolution_param().weight_filler())); weight_filler->Fill(this->blobs_[0].get()); // If necessary, initialize and fill the biases. if (bias_term_) { this->blobs_[1].reset(new Blob<Dtype>(bias_shape)); shared_ptr<Filler<Dtype> > bias_filler(GetFiller<Dtype>( this->layer_param_.convolution_param().bias_filler())); bias_filler->Fill(this->blobs_[1].get()); } } kernel_dim_ = this->blobs_[0]->count(1); weight_offset_ = conv_out_channels_ * kernel_dim_ / group_; // Propagate gradients to the parameters (as directed by backward pass). this->param_propagate_down_.resize(this->blobs_.size(), true); /* CS194 */ number_of_nodes_ = 8; threshold_ = Dtype(0.000625); weight_diff_size_ = conv_out_channels_ * kernel_dim_; vector<int> multi_stored_weight_diff_shape; multi_stored_weight_diff_shape.push_back(number_of_nodes_); multi_stored_weight_diff_shape.push_back(weight_diff_size_); multi_stored_weight_diff_.Reshape(multi_stored_weight_diff_shape); aggr_transferred_diffs_ = 0; aggr_would_transferred_diffs_ = 0; run_iteration_ = 0; }
/*------------------------------------------------------------------------ * object from tokens */ ogc_crs * ogc_crs :: from_tokens( const ogc_token * t, int start, int * pend, ogc_error * err) { if ( t == OGC_NULL ) { ogc_error::set(err, OGC_ERR_WKT_EMPTY_STRING, obj_kwd()); return OGC_NULL; } const char * kwd = t->_arr[start].str; # define CHECK(n) \ if ( ogc_##n::is_kwd(kwd) ) \ return ogc_##n :: from_tokens(t, start, pend, err) CHECK( engr_crs ); CHECK( geod_crs ); CHECK( image_crs ); CHECK( param_crs ); CHECK( proj_crs ); CHECK( time_crs ); CHECK( vert_crs ); CHECK( compound_crs ); CHECK( base_engr_crs ); CHECK( base_geod_crs ); CHECK( base_param_crs ); CHECK( base_proj_crs ); CHECK( base_time_crs ); CHECK( base_vert_crs ); # undef CHECK ogc_error::set(err, OGC_ERR_WKT_INVALID_KEYWORD, obj_kwd(), kwd); return OGC_NULL; }
void t4(int pi) { int h, e, f, n, s, b, l, seq_ok, toggle_ok; gpioReport_t r; char p[32]; printf("Pipe notification tests.\n"); set_PWM_frequency(pi, GPIO, 0); set_PWM_dutycycle(pi, GPIO, 0); set_PWM_range(pi, GPIO, 100); h = notify_open(pi); e = notify_begin(pi, h, (1<<GPIO)); CHECK(4, 1, e, 0, 0, "notify open/begin"); time_sleep(1); sprintf(p, "/dev/pigpio%d", h); f = open(p, O_RDONLY); set_PWM_dutycycle(pi, GPIO, 50); time_sleep(4); set_PWM_dutycycle(pi, GPIO, 0); e = notify_pause(pi, h); CHECK(4, 2, e, 0, 0, "notify pause"); e = notify_close(pi, h); CHECK(4, 3, e, 0, 0, "notify close"); n = 0; s = 0; l = 0; seq_ok = 1; toggle_ok = 1; while (1) { b = read(f, &r, 12); if (b == 12) { if (s != r.seqno) seq_ok = 0; if (n) if (l != (r.level&(1<<GPIO))) toggle_ok = 0; if (r.level&(1<<GPIO)) l = 0; else l = (1<<GPIO); s++; n++; // printf("%d %d %d %X\n", r.seqno, r.flags, r.tick, r.level); } else break; } close(f); CHECK(4, 4, seq_ok, 1, 0, "sequence numbers ok"); CHECK(4, 5, toggle_ok, 1, 0, "gpio toggled ok"); CHECK(4, 6, n, 80, 10, "number of notifications"); }
int main(void) { const nvlist_t *cnvl; nvlist_t *nvl; size_t size; printf("1..83\n"); nvl = nvlist_create(0); CHECK(!nvlist_exists_bool(nvl, "nvlist/bool/true")); nvlist_add_bool(nvl, "nvlist/bool/true", true); CHECK(nvlist_error(nvl) == 0); CHECK(nvlist_get_bool(nvl, "nvlist/bool/true") == true); CHECK(!nvlist_exists_bool(nvl, "nvlist/bool/false")); nvlist_add_bool(nvl, "nvlist/bool/false", false); CHECK(nvlist_error(nvl) == 0); CHECK(nvlist_get_bool(nvl, "nvlist/bool/false") == false); CHECK(!nvlist_exists_number(nvl, "nvlist/number/0")); nvlist_add_number(nvl, "nvlist/number/0", 0); CHECK(nvlist_error(nvl) == 0); CHECK(nvlist_get_number(nvl, "nvlist/number/0") == 0); CHECK(!nvlist_exists_number(nvl, "nvlist/number/1")); nvlist_add_number(nvl, "nvlist/number/1", 1); CHECK(nvlist_error(nvl) == 0); CHECK(nvlist_get_number(nvl, "nvlist/number/1") == 1); CHECK(!nvlist_exists_number(nvl, "nvlist/number/-1")); nvlist_add_number(nvl, "nvlist/number/-1", -1); CHECK(nvlist_error(nvl) == 0); CHECK((int)nvlist_get_number(nvl, "nvlist/number/-1") == -1); CHECK(!nvlist_exists_number(nvl, "nvlist/number/UINT64_MAX")); nvlist_add_number(nvl, "nvlist/number/UINT64_MAX", UINT64_MAX); CHECK(nvlist_error(nvl) == 0); CHECK(nvlist_get_number(nvl, "nvlist/number/UINT64_MAX") == UINT64_MAX); CHECK(!nvlist_exists_number(nvl, "nvlist/number/INT64_MIN")); nvlist_add_number(nvl, "nvlist/number/INT64_MIN", INT64_MIN); CHECK(nvlist_error(nvl) == 0); CHECK((int64_t)nvlist_get_number(nvl, "nvlist/number/INT64_MIN") == INT64_MIN); CHECK(!nvlist_exists_number(nvl, "nvlist/number/INT64_MAX")); nvlist_add_number(nvl, "nvlist/number/INT64_MAX", INT64_MAX); CHECK(nvlist_error(nvl) == 0); CHECK((int64_t)nvlist_get_number(nvl, "nvlist/number/INT64_MAX") == INT64_MAX); CHECK(!nvlist_exists_string(nvl, "nvlist/string/")); nvlist_add_string(nvl, "nvlist/string/", ""); CHECK(nvlist_error(nvl) == 0); CHECK(strcmp(nvlist_get_string(nvl, "nvlist/string/"), "") == 0); CHECK(!nvlist_exists_string(nvl, "nvlist/string/x")); nvlist_add_string(nvl, "nvlist/string/x", "x"); CHECK(nvlist_error(nvl) == 0); CHECK(strcmp(nvlist_get_string(nvl, "nvlist/string/x"), "x") == 0); CHECK(!nvlist_exists_string(nvl, "nvlist/string/abcdefghijklmnopqrstuvwxyz")); nvlist_add_string(nvl, "nvlist/string/abcdefghijklmnopqrstuvwxyz", "abcdefghijklmnopqrstuvwxyz"); CHECK(nvlist_error(nvl) == 0); CHECK(strcmp(nvlist_get_string(nvl, "nvlist/string/abcdefghijklmnopqrstuvwxyz"), "abcdefghijklmnopqrstuvwxyz") == 0); CHECK(!nvlist_exists_descriptor(nvl, "nvlist/descriptor/STDERR_FILENO")); nvlist_add_descriptor(nvl, "nvlist/descriptor/STDERR_FILENO", STDERR_FILENO); CHECK(nvlist_error(nvl) == 0); CHECK(fd_is_valid(nvlist_get_descriptor(nvl, "nvlist/descriptor/STDERR_FILENO"))); CHECK(!nvlist_exists_binary(nvl, "nvlist/binary/x")); nvlist_add_binary(nvl, "nvlist/binary/x", "x", 1); CHECK(nvlist_error(nvl) == 0); CHECK(memcmp(nvlist_get_binary(nvl, "nvlist/binary/x", NULL), "x", 1) == 0); CHECK(memcmp(nvlist_get_binary(nvl, "nvlist/binary/x", &size), "x", 1) == 0); CHECK(size == 1); CHECK(!nvlist_exists_binary(nvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz")); nvlist_add_binary(nvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz", "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz")); CHECK(nvlist_error(nvl) == 0); CHECK(memcmp(nvlist_get_binary(nvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz", NULL), "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz")) == 0); CHECK(memcmp(nvlist_get_binary(nvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz", &size), "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz")) == 0); CHECK(size == sizeof("abcdefghijklmnopqrstuvwxyz")); CHECK(!nvlist_exists_nvlist(nvl, "nvlist/nvlist")); nvlist_add_nvlist(nvl, "nvlist/nvlist", nvl); CHECK(nvlist_error(nvl) == 0); cnvl = nvlist_get_nvlist(nvl, "nvlist/nvlist"); CHECK(nvlist_get_bool(cnvl, "nvlist/bool/true") == true); CHECK(nvlist_get_bool(cnvl, "nvlist/bool/false") == false); CHECK(nvlist_get_number(cnvl, "nvlist/number/0") == 0); CHECK(nvlist_get_number(cnvl, "nvlist/number/1") == 1); CHECK((int)nvlist_get_number(cnvl, "nvlist/number/-1") == -1); CHECK(nvlist_get_number(cnvl, "nvlist/number/UINT64_MAX") == UINT64_MAX); CHECK((int64_t)nvlist_get_number(cnvl, "nvlist/number/INT64_MIN") == INT64_MIN); CHECK((int64_t)nvlist_get_number(cnvl, "nvlist/number/INT64_MAX") == INT64_MAX); CHECK(strcmp(nvlist_get_string(cnvl, "nvlist/string/"), "") == 0); CHECK(strcmp(nvlist_get_string(cnvl, "nvlist/string/x"), "x") == 0); CHECK(strcmp(nvlist_get_string(cnvl, "nvlist/string/abcdefghijklmnopqrstuvwxyz"), "abcdefghijklmnopqrstuvwxyz") == 0); /* TODO */ CHECK(memcmp(nvlist_get_binary(cnvl, "nvlist/binary/x", NULL), "x", 1) == 0); CHECK(memcmp(nvlist_get_binary(cnvl, "nvlist/binary/x", &size), "x", 1) == 0); CHECK(size == 1); CHECK(memcmp(nvlist_get_binary(cnvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz", NULL), "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz")) == 0); CHECK(memcmp(nvlist_get_binary(cnvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz", &size), "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz")) == 0); CHECK(size == sizeof("abcdefghijklmnopqrstuvwxyz")); CHECK(nvlist_get_bool(nvl, "nvlist/bool/true") == true); CHECK(nvlist_get_bool(nvl, "nvlist/bool/false") == false); CHECK(nvlist_get_number(nvl, "nvlist/number/0") == 0); CHECK(nvlist_get_number(nvl, "nvlist/number/1") == 1); CHECK((int)nvlist_get_number(nvl, "nvlist/number/-1") == -1); CHECK(nvlist_get_number(nvl, "nvlist/number/UINT64_MAX") == UINT64_MAX); CHECK((int64_t)nvlist_get_number(nvl, "nvlist/number/INT64_MIN") == INT64_MIN); CHECK((int64_t)nvlist_get_number(nvl, "nvlist/number/INT64_MAX") == INT64_MAX); CHECK(strcmp(nvlist_get_string(nvl, "nvlist/string/"), "") == 0); CHECK(strcmp(nvlist_get_string(nvl, "nvlist/string/x"), "x") == 0); CHECK(strcmp(nvlist_get_string(nvl, "nvlist/string/abcdefghijklmnopqrstuvwxyz"), "abcdefghijklmnopqrstuvwxyz") == 0); CHECK(fd_is_valid(nvlist_get_descriptor(nvl, "nvlist/descriptor/STDERR_FILENO"))); CHECK(memcmp(nvlist_get_binary(nvl, "nvlist/binary/x", NULL), "x", 1) == 0); CHECK(memcmp(nvlist_get_binary(nvl, "nvlist/binary/x", &size), "x", 1) == 0); CHECK(size == 1); CHECK(memcmp(nvlist_get_binary(nvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz", NULL), "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz")) == 0); CHECK(memcmp(nvlist_get_binary(nvl, "nvlist/binary/abcdefghijklmnopqrstuvwxyz", &size), "abcdefghijklmnopqrstuvwxyz", sizeof("abcdefghijklmnopqrstuvwxyz")) == 0); CHECK(size == sizeof("abcdefghijklmnopqrstuvwxyz")); nvlist_destroy(nvl); return (0); }
void BaseConvolutionLayer<Dtype>::LayerSetUp(const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) { CHECK_EQ(4, bottom[0]->num_axes()) << "Input must have 4 axes, " << "corresponding to (num, channels, height, width)"; // Configure the kernel size, padding, stride, and inputs. ConvolutionParameter conv_param = this->layer_param_.convolution_param(); CHECK(!conv_param.has_kernel_size() != !(conv_param.has_kernel_h() && conv_param.has_kernel_w())) << "Filter size is kernel_size OR kernel_h and kernel_w; not both"; CHECK(conv_param.has_kernel_size() || (conv_param.has_kernel_h() && conv_param.has_kernel_w())) << "For non-square filters both kernel_h and kernel_w are required."; CHECK((!conv_param.has_pad() && conv_param.has_pad_h() && conv_param.has_pad_w()) || (!conv_param.has_pad_h() && !conv_param.has_pad_w())) << "pad is pad OR pad_h and pad_w are required."; CHECK((!conv_param.has_stride() && conv_param.has_stride_h() && conv_param.has_stride_w()) || (!conv_param.has_stride_h() && !conv_param.has_stride_w())) << "Stride is stride OR stride_h and stride_w are required."; if (conv_param.has_kernel_size()) { kernel_h_ = kernel_w_ = conv_param.kernel_size(); } else { kernel_h_ = conv_param.kernel_h(); kernel_w_ = conv_param.kernel_w(); } CHECK_GT(kernel_h_, 0) << "Filter dimensions cannot be zero."; CHECK_GT(kernel_w_, 0) << "Filter dimensions cannot be zero."; if (!conv_param.has_pad_h()) { pad_h_ = pad_w_ = conv_param.pad(); } else { pad_h_ = conv_param.pad_h(); pad_w_ = conv_param.pad_w(); } if (!conv_param.has_stride_h()) { stride_h_ = stride_w_ = conv_param.stride(); } else { stride_h_ = conv_param.stride_h(); stride_w_ = conv_param.stride_w(); } // Special case: im2col is the identity for 1x1 convolution with stride 1 // and no padding, so flag for skipping the buffer and transformation. is_1x1_ = kernel_w_ == 1 && kernel_h_ == 1 && stride_h_ == 1 && stride_w_ == 1 && pad_h_ == 0 && pad_w_ == 0; // Configure output channels and groups. channels_ = bottom[0]->channels(); num_output_ = this->layer_param_.convolution_param().num_output(); CHECK_GT(num_output_, 0); group_ = this->layer_param_.convolution_param().group(); CHECK_EQ(channels_ % group_, 0); CHECK_EQ(num_output_ % group_, 0) << "Number of output should be multiples of group."; if (reverse_dimensions()) { conv_out_channels_ = channels_; conv_in_channels_ = num_output_; } else { conv_out_channels_ = num_output_; conv_in_channels_ = channels_; } // Handle the parameters: weights and biases. // - blobs_[0] holds the filter weights // - blobs_[1] holds the biases (optional) bias_term_ = this->layer_param_.convolution_param().bias_term(); if (this->blobs_.size() > 0) { LOG(INFO) << "Skipping parameter initialization"; } else { if (bias_term_) { this->blobs_.resize(2); } else { this->blobs_.resize(1); } // Initialize and fill the weights: // output channels x input channels per-group x kernel height x kernel width this->blobs_[0].reset(new Blob<Dtype>( conv_out_channels_, conv_in_channels_ / group_, kernel_h_, kernel_w_)); shared_ptr<Filler<Dtype> > weight_filler(GetFiller<Dtype>( this->layer_param_.convolution_param().weight_filler())); weight_filler->Fill(this->blobs_[0].get()); // If necessary, initialize and fill the biases. if (bias_term_) { vector<int> bias_shape(1, num_output_); this->blobs_[1].reset(new Blob<Dtype>(bias_shape)); shared_ptr<Filler<Dtype> > bias_filler(GetFiller<Dtype>( this->layer_param_.convolution_param().bias_filler())); bias_filler->Fill(this->blobs_[1].get()); } } // Propagate gradients to the parameters (as directed by backward pass). this->param_propagate_down_.resize(this->blobs_.size(), true); }
int main(int argc,char * argv[]) { int i = 0, j = 0, rc; MDB_env *env; MDB_dbi dbi; MDB_val key, data; MDB_txn *txn; MDB_stat mst; MDB_cursor *cursor; int count; int *values; char sval[32] = ""; int env_oflags; struct stat db_stat, exe_stat; srand(time(NULL)); count = (rand()%384) + 64; values = (int *)malloc(count*sizeof(int)); for(i = 0;i<count;i++) { values[i] = rand()%1024; } E(mdb_env_create(&env)); E(mdb_env_set_maxreaders(env, 1)); E(mdb_env_set_mapsize(env, 10485760)); E(mdb_env_set_maxdbs(env, 4)); E(stat("/proc/self/exe", &exe_stat)?errno:0); E(stat(DBPATH "/.", &db_stat)?errno:0); env_oflags = MDB_FIXEDMAP | MDB_NOSYNC; if (major(db_stat.st_dev) != major(exe_stat.st_dev)) { /* LY: Assume running inside a CI-environment: * 1) don't use FIXEDMAP to avoid EBUSY in case collision, * which could be inspired by address space randomisation feature. * 2) drop MDB_NOSYNC expecting that DBPATH is at a tmpfs or some dedicated storage. */ env_oflags = 0; } /* LY: especially here we always needs MDB_NOSYNC * for testing mdb_env_close_ex() and "redo-to-steady" on open. */ env_oflags |= MDB_NOSYNC; E(mdb_env_open(env, DBPATH, env_oflags, 0664)); E(mdb_txn_begin(env, NULL, 0, &txn)); if (mdb_dbi_open(txn, "id1", MDB_CREATE, &dbi) == MDB_SUCCESS) E(mdb_drop(txn, dbi, 1)); E(mdb_dbi_open(txn, "id1", MDB_CREATE, &dbi)); key.mv_size = sizeof(int); key.mv_data = sval; data.mv_size = sizeof(sval); data.mv_data = sval; printf("Adding %d values\n", count); for (i=0;i<count;i++) { sprintf(sval, "%03x %d foo bar", values[i], values[i]); if (RES(MDB_KEYEXIST, mdb_put(txn, dbi, &key, &data, MDB_NOOVERWRITE))) j++; } if (j) printf("%d duplicates skipped\n", j); E(mdb_txn_commit(txn)); E(mdb_env_stat(env, &mst)); printf("check-preset-a\n"); E(mdb_txn_begin(env, NULL, MDB_RDONLY, &txn)); E(mdb_cursor_open(txn, dbi, &cursor)); int present_a = 0; while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_NEXT)) == 0) { printf("key: %p %.*s, data: %p %.*s\n", key.mv_data, (int) key.mv_size, (char *) key.mv_data, data.mv_data, (int) data.mv_size, (char *) data.mv_data); ++present_a; } CHECK(rc == MDB_NOTFOUND, "mdb_cursor_get"); CHECK(present_a == count - j, "mismatch"); mdb_cursor_close(cursor); mdb_txn_abort(txn); mdb_env_sync(env, 1); j=0; key.mv_data = sval; for (i= count - 1; i > -1; i-= (rand()%5)) { j++; txn=NULL; E(mdb_txn_begin(env, NULL, 0, &txn)); sprintf(sval, "%03x ", values[i]); if (RES(MDB_NOTFOUND, mdb_del(txn, dbi, &key, NULL))) { j--; mdb_txn_abort(txn); } else { E(mdb_txn_commit(txn)); } } free(values); printf("Deleted %d values\n", j); printf("check-preset-b.cursor-next\n"); E(mdb_env_stat(env, &mst)); E(mdb_txn_begin(env, NULL, MDB_RDONLY, &txn)); E(mdb_cursor_open(txn, dbi, &cursor)); int present_b = 0; while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_NEXT)) == 0) { printf("key: %.*s, data: %.*s\n", (int) key.mv_size, (char *) key.mv_data, (int) data.mv_size, (char *) data.mv_data); ++present_b; } CHECK(rc == MDB_NOTFOUND, "mdb_cursor_get"); CHECK(present_b == present_a - j, "mismatch"); printf("check-preset-b.cursor-prev\n"); j = 1; while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_PREV)) == 0) { printf("key: %.*s, data: %.*s\n", (int) key.mv_size, (char *) key.mv_data, (int) data.mv_size, (char *) data.mv_data); ++j; } CHECK(rc == MDB_NOTFOUND, "mdb_cursor_get"); CHECK(present_b == j, "mismatch"); mdb_cursor_close(cursor); mdb_txn_abort(txn); mdb_dbi_close(env, dbi); /********************* LY: kept DB dirty ****************/ mdb_env_close_ex(env, 1); E(mdb_env_create(&env)); E(mdb_env_set_maxdbs(env, 4)); E(mdb_env_open(env, DBPATH, env_oflags, 0664)); printf("check-preset-c.cursor-next\n"); E(mdb_env_stat(env, &mst)); E(mdb_txn_begin(env, NULL, MDB_RDONLY, &txn)); E(mdb_dbi_open(txn, "id1", 0, &dbi)); E(mdb_cursor_open(txn, dbi, &cursor)); int present_c = 0; while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_NEXT)) == 0) { printf("key: %.*s, data: %.*s\n", (int) key.mv_size, (char *) key.mv_data, (int) data.mv_size, (char *) data.mv_data); ++present_c; } CHECK(rc == MDB_NOTFOUND, "mdb_cursor_get"); CHECK(present_c == present_a, "mismatch"); printf("check-preset-d.cursor-prev\n"); j = 1; while ((rc = mdb_cursor_get(cursor, &key, &data, MDB_PREV)) == 0) { printf("key: %.*s, data: %.*s\n", (int) key.mv_size, (char *) key.mv_data, (int) data.mv_size, (char *) data.mv_data); ++j; } CHECK(rc == MDB_NOTFOUND, "mdb_cursor_get"); CHECK(present_c == j, "mismatch"); mdb_cursor_close(cursor); mdb_txn_abort(txn); mdb_dbi_close(env, dbi); mdb_env_close_ex(env, 0); return 0; }
void ImageDataLayer<Dtype>::InternalThreadEntry() { CPUTimer batch_timer; batch_timer.Start(); double read_time = 0; double trans_time = 0; CPUTimer timer; CHECK(this->prefetch_data_.count()); CHECK(this->transformed_data_.count()); ImageDataParameter image_data_param = this->layer_param_.image_data_param(); const int batch_size = image_data_param.batch_size(); const int new_height = image_data_param.new_height(); const int new_width = image_data_param.new_width(); const int crop_size = this->layer_param_.transform_param().crop_size(); const bool is_color = image_data_param.is_color(); string root_folder = image_data_param.root_folder(); // Reshape on single input batches for inputs of varying dimension. if (batch_size == 1 && crop_size == 0 && new_height == 0 && new_width == 0) { cv::Mat cv_img = ReadImageToCVMat(root_folder + lines_[lines_id_].first, 0, 0, is_color); this->prefetch_data_.Reshape(1, cv_img.channels(), cv_img.rows, cv_img.cols); this->transformed_data_.Reshape(1, cv_img.channels(), cv_img.rows, cv_img.cols); } Dtype* prefetch_data = this->prefetch_data_.mutable_cpu_data(); Dtype* prefetch_label = this->prefetch_label_.mutable_cpu_data(); // datum scales const int lines_size = lines_.size(); for (int item_id = 0; item_id < batch_size; ++item_id) { // get a blob timer.Start(); CHECK_GT(lines_size, lines_id_); cv::Mat cv_img = ReadImageToCVMat(root_folder + lines_[lines_id_].first, new_height, new_width, is_color); CHECK(cv_img.data) << "Could not load " << lines_[lines_id_].first; read_time += timer.MicroSeconds(); timer.Start(); // Apply transformations (mirror, crop...) to the image int offset = this->prefetch_data_.offset(item_id); this->transformed_data_.set_cpu_data(prefetch_data + offset); this->data_transformer_->Transform(cv_img, &(this->transformed_data_)); trans_time += timer.MicroSeconds(); for (int label_i = 0; label_i < image_data_param.label_size(); ++label_i){ prefetch_label[ item_id * image_data_param.label_size() + label_i] = lines_[lines_id_].second[label_i]; } // prefetch_label[item_id] = lines_[lines_id_].second; // go to the next iter lines_id_++; if (lines_id_ >= lines_size) { // We have reached the end. Restart from the first. DLOG(INFO) << "Restarting data prefetching from start."; lines_id_ = 0; if (this->layer_param_.image_data_param().shuffle()) { ShuffleImages(); } } } batch_timer.Stop(); DLOG(INFO) << "Prefetch batch: " << batch_timer.MilliSeconds() << " ms."; DLOG(INFO) << " Read time: " << read_time / 1000 << " ms."; DLOG(INFO) << "Transform time: " << trans_time / 1000 << " ms."; }
SEXP setMeCabMap(int typeSet, char input[], map<string, int> & ma0, map<string, int> & ma1, map<string, int>::iterator & pma0, map<string, int>::iterator & pma, list <string> & strL, list <string>::iterator & iter, list <string> & hinsi, list <string>::iterator & hinsi_it, list <string> & saibun, list <string>::iterator & saibun_it, vector<string> & Ppos2, int pos_n, int Ngram, int genkei, const char * dic ){// map<string, int> & ma1, char *Ppos[], mecab_t *mecab; mecab_node_t *node; int i, j , posC = 0, xx =0; char buf1 [BUF1];// 2010 12 17 //[128];// [512];//入力された語形を記憶 char buf2[BUF3]; char buf3[BUF2];// 2010 12 17 //[64];// [512];記号チェック用 char buf4[BUF2];// 2010 12 17 //[64];// [1024];記号チェック用 string str; char *p; wchar_t wbuf [BUF4] ;// = { 0 }; //wchar_t wbuf [5120] = { 0 }; /* ワイド文字列 : 日本語文字数 + 1 */ memset (wbuf, 0, sizeof wbuf); // 2015 12 18 unsigned int wz = 0; string target; char target2[BUF3]; // http://mecab.sourceforge.net/mecab.html mecab = mecab_new2 (dic);// mecab = mecab_new2 ("めかぶ");// mecab_new2 (" -u user.dic");mecab_new2(" -d mecab\dic\ipadic -O ruby"); CHECK(mecab); //Rprintf("%s strlen of input= %d\n", input, strlen(input)); if(typeSet == 0){// 文字単位なら // Rprintf("in typeSet == 0 %s \n", file_name ); // Rprintf("%s\n", input); p = strchr( input, '\n' ); /* 改行文字があった場合 */ if ( p != NULL ) { /* 改行文字を終端文字に置き換える */ *p = '\0'; } // Rprintf("strlen of input= %d\n", strlen(input)); if(strlen(input) > 0){ //Rprintf("%s\n", input); // Rprintf("in strlen(input) > 0 %s \n", file_name ); mbstowcs(wbuf, input, strlen(input));/* マルチバイト文字列をワイド文字列に変換*/ //for(int z = 0; z < (wcslen(wbuf) - Ngram); z++){ for( wz = 0; wz < wcslen(wbuf) ; wz++){ // 2005 07 22 // 2008 04 05 #if defined(_WIN64) || !defined(_WIN32) // defined(__MINGW32__) || defined(__MINGW64__ #if defined(WIN32) || defined(WIN64) || defined(_WIN32) || defined(_WIN64) wsprintf(target2, "%lc", wbuf[wz]);// windows では wsprintf #elif defined(__MINGW32__) || defined(__WINGW64__) wsprintf(target2, "%lc", wbuf[wz]);// windows では wsprintf #else sprintf(target2, "%lc", wbuf[wz]);// Linux では sprintf #endif // Rprintf("target2 = %s\n", target2); if(strlen(target2) < 1){ break; } //エスケープ記号類 //strcpy(buf1, *target2); if( *target2 > 0x00 && *target2 < 0x21 ){//エスケープ記号類0x0e continue; }// //////////// windows では wsprintf(str[ys], "%lc", wbuf[z+ys + yw]); // if( strcmp(target2, " ") == 0 || strcmp(target2, " ")==0){ if( strcmp((char *) target2, " ") == 0 || strcmp((char *) target2, " ")==0){ // printf("found\n"); continue; } else{ /////////////// new_begin //////////////// ここは文字単位 // target = target2; strL.push_back( target2); if(strL.size() >= (unsigned int) Ngram){ // Rprintf("in if(strL.size) \n"); target.erase(); //target.append("["); xx = 1; for ( iter = strL.begin(); iter != strL.end(); iter++){ // Rprintf("in for\n"); // Rprintf("str %s\n", * iter); target.append( *iter); if(xx < Ngram){ target.append(" ");//target.append("-"); } xx++; // Rprintf("xx = %d\n", xx); } xx = 1; //target.append("]"); // Rprintf("target %s\n", target); // Rprintf("before m1.find \n"); //出てきた形態素原型は既に全体マップにあるか? pma = ma0.find(target); //出てきた形態素原型は既にマップにあるか? if(pma != ma0.end()){ pma->second = pma->second + 1; //二つ目の数値を加算 } else{// マップにないなら,新規にマップに追加 // Rprintf("add map \n"); ma0.insert(make_pair(target, 1));// 1 は 1個目と言う意味 } // 同じ処理を個別マップにも行う pma = ma1.find(target);//出てきた形態素原型は既に個別マップにあるか? if(pma != ma1.end()){ pma->second = pma->second + 1; //二つ目の数値を加算 } else{// マップにないなら,新規にマップに追加 ma1.insert(make_pair(target, 1));// 1 は 1個目と言う意味 } strL.pop_front(); }//_if strSize>= Ngram }// _else_end ////////////////////////////////////// new _end //// }//_for2_< wcslen }// if_strlen_>_0_end } else {// if_type_set 形態素あるいは品詞の場合 //////////////////////////////////////////////////////////////// // Rprintf("after fgets input = %s\n",input ); node = ( mecab_node_t * ) mecab_sparse_tonode(mecab, input); CHECK(node); // Rprintf("node check" ); /// 解析結果のノードをなめる for (; node; node = node->next) {// node とはその文の形態素ごとに設定される // printf("%d ", node->id); if (node->stat == MECAB_BOS_NODE) //printf("BOS"); continue; else if (node->stat == MECAB_EOS_NODE) //printf("EOS"); continue; else {// BOS, EOS 以外 // 2010 buf1 = (char *)malloc( node->length * MB_CUR_MAX+ 1); strncpy(buf1, node->surface, node->length) ;//元の語形 buf1[node->length] = '\0';// 末尾にNULLを加える// 2006 06 移動 // strlen関数はstringの文字数を返します。この長さには、終端のNULL文字('\0')は含まれません。 if(strlen(buf1) < 1){// 2006 06 移動 continue; } //< 2005 11 07> //Rprintf("%s\n", buf1); //if( atoi(buf1) > 0x00 && atoi(buf1) < 0x0e ){// if( atoi(buf1) == 0x0e){//エスケープ記号類 if( buf1[0] > 0x00 && buf1[0] < 0x21 ){//エスケープ記号類0x0e // strlen(buf1) == 1 && continue; }// </ 2005 11 07> // buf1[node->length] = '\0';// 末尾にNULLを加える// 2006 06 移動 // if(strlen(buf1) < 1){// 2006 06 移動 // continue; // } // Rprintf("buf1 = %s\n", buf1); strcpy(buf2, node->feature);//ノードごとに解析情報の取得.要素数は 9 if(strlen(buf2) < 1){ continue; } // Rprintf("buf2 = %s\n", buf2); ////////////// p = strtok(buf2, "," );//取得情報の分割 // 品詞の判定 j = 1; //////////////////////////////////////////////////////////////////// if(typeSet == 2){// 品詞情報で数える if( j == 1 && p != NULL ){//品詞情報1 strL.push_back(p); // Rprintf("typeSet == = %d; p = %s\n", typeSet, p); p = NULL; } }else if(typeSet == 1){// 形態素原形で数える ////////////////////////////////////////////// if(j == 1 && p != NULL){ sprintf(buf3, "%s", p); // // if(mSym < 1 && strcmp(buf3, "記号") == 0){ // if(mSym < 1 && strcmp(buf3, KIGO) == 0){ // p = NULL; // //j = 9; // continue;// 記号は一切省き,総計にも加えない // } // // // Rprintf("buf3 %s\n", buf3); if(pos_n == 0){ hinsi.push_back(buf3); posC = 1; }else{ for(i = 0; i < pos_n; i++){ sprintf(buf4, "%s", Ppos2[i].c_str()); // 2011 03 10 sprintf(buf4, "%s", Ppos[i]); // Rprintf("buf4 %s\n", buf4); if(strcmp(buf3, buf4) == 0){ posC = 1; hinsi.push_back(buf3); break; } } } if(posC != 1){ p = NULL; posC = 0; continue; } } while ( p != NULL ) { // if(j == 1){//品詞情報1 // str = p; // // str.append(","); // }else if(j == 2){//品詞第2情報 saibun.push_back(p); } else if( j == 7){ if(genkei == 1 || p == NULL || strcmp(p, "*") == 0){ // strL.push_back(p);//原型str = buf1;// str.append(buf1);//元の語形 strL.push_back(buf1);//元の語形 //Rprintf("in str = buf1\n"); } else{ strL.push_back(p);//原型 strL.push_back(buf1); //Rprintf("in str = p\n"); } } p = strtok( NULL,"," ); j++; if(j > 7){ p = NULL; } }// while(P!= NULL) posC = 0; } // else if typset = 1 } //////else // BOS, EOS 以外 ////////////// 抽出終了 if(strL.size() >= (unsigned int) Ngram){// リストのサイズが指定通りであるなら,保存を始める // Rprintf("type = %d, strL size = %d\n", typeSet, strL.size() ); target.erase();//保存のための文字列を初期化 target.append(""); xx = 1; for ( iter = strL.begin(); iter != strL.end(); iter++){ // Rprintf("in for\n"); //sprintf(buf3, "%s", *iter); //Rprintf("str %s\n", *iter); //Rprintf("after Rprintf in for\n"); target.append( *iter);// target.append( buf3); //target.append( *iter); // Rprintf("target append\n"); if(xx < Ngram){ target.append(" ");//target.append("-"); } xx++; } // for xx = 1; if(typeSet == 1){ target.append(" "); for ( hinsi_it = hinsi.begin(); hinsi_it != hinsi.end(); hinsi_it++){ // Rprintf("in for\n"); //sprintf(buf3, "%s", *iter); //Rprintf("str %s\n", *iter); //Rprintf("after Rprintf in for\n"); target.append( *hinsi_it);// target.append( buf3); //target.append( *iter); // Rprintf("target append\n"); if(xx < Ngram){ target.append(" ");//target.append("-"); } xx++; } // for xx = 1; target.append(" "); for ( saibun_it = saibun.begin(); saibun_it != saibun.end(); saibun_it++){ // Rprintf("in for\n"); //sprintf(buf3, "%s", *iter); //Rprintf("str %s\n", *iter); //Rprintf("after Rprintf in for\n"); target.append( *saibun_it);// target.append( buf3); //target.append( *iter); // Rprintf("target append\n"); if(xx < Ngram){ target.append(" ");//target.append("-"); } xx++; } // for xx = 1; }//if(typeSet == 1){ pma0 = ma0.find(target);//出てきた形態素原型は既に全体マップにあるか? if(pma0 != ma0.end()){ pma0->second = pma0->second + 1; //二つ目の数値を加算 } else{// マップにないなら,新規にマップに追加 ma0.insert(make_pair(target, 1));// 1 は 1個目と言う意味 } pma = ma1.find(target);// str 出てきた形態素原型は既に個別マップにあるか? if(pma != ma1.end()){ pma->second = pma->second + 1; //二つ目の数値を加算 } else{// マップにないなら,新規にマップに追加 ma1.insert(make_pair(target, 1));// 1 は 1個目と言う意味 } strL.pop_front();// 最初の要素を取り除く if(typeSet == 1){ hinsi.pop_front(); saibun.pop_front(); } } // if(strL.size() >= Ngram) }//for(;node;)// Rprintf("node check ended\n"); } mecab_destroy(mecab); return (R_NilValue);// return 0; }
// Function definitions. // ----------------------------------------------------------------- void mexFunction (int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { //Input Args double *x0; //Outputs Args double *x, *fval, *exitflag, *iter, *feval; //Internal Vars size_t ndec; int printLevel = 0; //M1QN3 Vars int m = 5, n, indic, ndz; int uiparm[2] = {1,0}; //user integer array [citer, printLevel] double *g, dxmin = 1e-8, df1, epsg = 1e-6, *dz; char *normtype = "dfn"; int impres = 4, io = 18, omode = 0, reverse = 0; int imode[3] = {0,0,0}; //DIS, cold start, no SIMUL with indic = 1 int iz[5]; float *rzs = NULL; double *dzs = NULL; //dummy args //Defaults int maxfev = 1500; int maxiter = 1000; maxtime = 1000; iterF.enabled = false; if (nrhs < 1) { if(nlhs < 1) mexPrintf("\nThis is M1QN3 v%s MEX Interface\n",M1QN3_VERSION); else plhs[0] = mxCreateString(M1QN3_VERSION); return; } //Check user inputs checkInputs(prhs,nrhs); //Get Sizes ndec = mxGetNumberOfElements(pX0); //Get Objective Function Handle if (mxIsChar(pFUN)) { CHECK(mxGetString(pFUN, fun.f, FLEN) == 0,"error reading objective name string"); fun.nrhs = 1; fun.xrhs = 0; } else { fun.prhs[0] = (mxArray*)pFUN; strcpy(fun.f, "feval"); fun.nrhs = 2; fun.xrhs = 1; } fun.prhs[fun.xrhs] = mxCreateDoubleMatrix(ndec, 1, mxREAL); //x0 //Get Gradient Function Handle if (mxIsChar(pGRAD)) { CHECK(mxGetString(pGRAD, fun.g, FLEN) == 0,"error reading gradient name string"); fun.nrhs_g = 1; fun.xrhs_g = 0; } else { fun.prhs_g[0] = (mxArray*)pGRAD; strcpy(fun.g, "feval"); fun.nrhs_g = 2; fun.xrhs_g = 1; } fun.prhs_g[fun.xrhs_g] = mxCreateDoubleMatrix(ndec, 1, mxREAL); //x0 //Get x0 x0 = mxGetPr(pX0); //Get Options if specified if(nrhs > eOPTS) { if(mxGetField(pOPTS,0,"display")) printLevel = (int)*mxGetPr(mxGetField(pOPTS,0,"display")); if(mxGetField(pOPTS,0,"maxfeval")) maxfev = (int)*mxGetPr(mxGetField(pOPTS,0,"maxfeval")); if(mxGetField(pOPTS,0,"maxiter")) maxiter = (int)*mxGetPr(mxGetField(pOPTS,0,"maxiter")); if(mxGetField(pOPTS,0,"maxtime")) maxtime = *mxGetPr(mxGetField(pOPTS,0,"maxtime")); if(mxGetField(pOPTS,0,"tolafun")) epsg = *mxGetPr(mxGetField(pOPTS,0,"tolafun")); //not function tolerance (gradient) if(mxGetField(pOPTS,0,"nupdates")) m = (int)*mxGetPr(mxGetField(pOPTS,0,"nupdates")); //number of l-bfgs updates if(mxGetField(pOPTS,0,"iterfun") && !mxIsEmpty(mxGetField(pOPTS,0,"iterfun"))) { iterF.prhs[0] = (mxArray*)mxGetField(pOPTS,0,"iterfun"); strcpy(iterF.f, "feval"); iterF.enabled = true; iterF.prhs[1] = mxCreateNumericMatrix(1,1,mxINT32_CLASS,mxREAL); iterF.prhs[2] = mxCreateDoubleMatrix(1,1,mxREAL); iterF.prhs[3] = mxCreateDoubleMatrix(ndec,1,mxREAL); } } //Create Outputs plhs[0] = mxCreateDoubleMatrix(ndec,1, mxREAL); plhs[1] = mxCreateDoubleMatrix(1,1, mxREAL); plhs[2] = mxCreateDoubleMatrix(1,1, mxREAL); plhs[3] = mxCreateDoubleMatrix(1,1, mxREAL); plhs[4] = mxCreateDoubleMatrix(1,1, mxREAL); x = mxGetPr(plhs[0]); fval = mxGetPr(plhs[1]); exitflag = mxGetPr(plhs[2]); iter = mxGetPr(plhs[3]); feval = mxGetPr(plhs[4]); //Copy initial guess to x memcpy(x,x0,ndec*sizeof(double)); //Print Header if(printLevel) { mexPrintf("\n------------------------------------------------------------------\n"); mexPrintf(" This is M1QN3 v%s\n",M1QN3_VERSION); mexPrintf(" Authors: Jean Charles Gilbert, Claude Lemarechal, INRIA\n MEX Interface J. Currie 2012\n\n"); mexPrintf(" Problem Properties:\n"); mexPrintf(" # Decision Variables: %4d\n",ndec); mexPrintf("------------------------------------------------------------------\n"); } //Assign Arguments n = (int)ndec; indic = 4; g = (double*)mxCalloc(n,sizeof(double)); //allocate memory for gradient ndz = 4*n + m*(2*n + 1); dz = (double*)mxCalloc(ndz,sizeof(double)); //Start timer start = clock(); //Initialization Call SIMUL(&indic, &n, x, fval, g, uiparm, NULL, NULL); //Set df1 (initial estiamte of f reduction) df1 = *fval; //MEX Options uiparm[0] = 1; uiparm[1] = printLevel; // FILE* myFile = fopen("myFile.txt","w"); // fprintf(myFile,"Hello world!\n"); // fclose(myFile); //Call Algorithm M1QN3(SIMUL,EUCLID,CTONBE,CTCABE,&n,x,fval,g,&dxmin,&df1,&epsg,normtype, &impres,&io,imode,&omode,&maxiter,&maxfev,iz,dz,&ndz,&reverse,&indic, uiparm,rzs,dzs); //Save Status & Iterations *exitflag = (double)omode; *iter = maxiter; *feval = maxfev; //Check if maxtime exceeded if(((double)(end-start))/CLOCKS_PER_SEC > maxtime) *exitflag = 8; //Print Header if(printLevel){ //Termination Detected switch((int)*exitflag) { //Success case 1: mexPrintf("\n *** SUCCESSFUL TERMINATION ***\n *** gradient convergence |gk|/|g1| < epsg ***\n"); break; //Error case 5: mexPrintf("\n *** MAXIMUM FUNCTION EVALUATIONS REACHED ***\n"); break; case 4: mexPrintf("\n *** MAXIMUM ITERATIONS REACHED ***\n"); break; case 8: mexPrintf("\n *** MAXIMUM TIME REACHED ***\n"); break; case 2: mexPrintf("\n *** ERROR: one of the input arguments is not well initialized ***\n"); break; case 3: mexPrintf("\n *** ERROR: the line-search is blocked on tmax = 10^20 ***\n"); break; case 6: mexPrintf("\n *** ERROR: stop dxmin during the line-search ***\n"); break; case 7: mexPrintf("\n *** ERROR: either (g,d) is nonnegative or (y,s) is nonpositive ***\n"); break; //Early Exit case 0: mexPrintf("\n *** TERMINATION: USER EXITED ***\n"); break; //Other Error default: mexPrintf("\n *** ERROR: internal error code %d ***\n",omode); break; } if(*exitflag==1) mexPrintf("\n Final fval: %12.5g\n In %3.0f iterations\n",*fval,*iter); mexPrintf("------------------------------------------------------------------\n\n"); } //Free Memory mxFree(g); mxFree(dz); }
static ssize_t NaClGioShmReadOrWrite(struct Gio *vself, void *buf, size_t count, int is_write) { struct NaClGioShm *self = (struct NaClGioShm *) vself; size_t new_window_offset; size_t transfer; size_t window_end; size_t window_remain; size_t sofar; NaClLog(4, ("NaClGioShmReadOrWrite: 0x%"NACL_PRIxPTR"," " 0x%"NACL_PRIxPTR", 0x%"NACL_PRIxS", %d\n"), (uintptr_t) vself, (uintptr_t) buf, count, is_write); sofar = 0; while (count > 0) { NaClLog(4, "NaClGioShmReadOrWrite: count 0x%"NACL_PRIxS"\n", count); if (self->io_offset >= self->shm_sz) { break; } NaClLog(4, " cur_window 0x%"NACL_PRIxPTR"\n", (uintptr_t) self->cur_window); NaClLog(4, " io_offset 0x%"NACL_PRIxS"\n", self->io_offset); NaClLog(4, "window_offset 0x%"NACL_PRIxS"\n", self->window_offset); if (NULL == self->cur_window || self->io_offset < self->window_offset || self->window_offset + self->window_size <= self->io_offset) { /* * io_offset is outside the window. move the window so that * it's within. */ NaClLog(4, "Seek required\n"); new_window_offset = (self->io_offset & (~(((size_t) NACL_MAP_PAGESIZE) - 1))); NaClLog(4, "new_window_offset 0x%"NACL_PRIxS"\n", new_window_offset); CHECK(0 == (new_window_offset & (((size_t) NACL_MAP_PAGESIZE)-1))); if (!NaClGioShmSetWindow(self, new_window_offset)) { if (0 == sofar) { errno = EIO; sofar = -1; } return sofar; } } else { NaClLog(4, "no seek required\n"); } NaClLog(4, " cur_window 0x%"NACL_PRIxPTR"\n", (uintptr_t) self->cur_window); NaClLog(4, " io_offset 0x%"NACL_PRIxS"\n", self->io_offset); NaClLog(4, "window_offset 0x%"NACL_PRIxS"\n", self->window_offset); CHECK(self->window_offset <= self->io_offset); CHECK(self->io_offset < self->window_offset + self->window_size); transfer = count; window_end = self->window_offset + self->window_size; if (window_end > self->shm_sz) { window_end = self->shm_sz; } window_remain = window_end - self->io_offset; NaClLog(4, "remaining in window 0x%"NACL_PRIxS"\n", window_remain); CHECK(window_remain <= GIO_SHM_WINDOWSIZE); if (transfer > window_remain) { transfer = window_remain; } NaClLog(4, "transfer 0x%"NACL_PRIxS"\n", transfer); if (is_write) { NaClLog(4, ("about to \"write\" memcpy(0x%"NACL_PRIxPTR", " " 0x%"NACL_PRIxPTR", 0x%"NACL_PRIxS" bytes)\n"), (uintptr_t) (self->cur_window + (self->io_offset - self->window_offset)), (uintptr_t) buf, transfer); memcpy(self->cur_window + (self->io_offset - self->window_offset), buf, transfer); } else { NaClLog(4, ("about to \"read\" memcpy(0x%"NACL_PRIxPTR", " " 0x%"NACL_PRIxPTR", 0x%"NACL_PRIxS" bytes)\n"), (uintptr_t) buf, (uintptr_t) (self->cur_window + (self->io_offset - self->window_offset)), transfer); memcpy(buf, self->cur_window + (self->io_offset - self->window_offset), transfer); } self->io_offset += transfer; sofar += transfer; buf = (void *)((uintptr_t) buf + transfer); count -= transfer; } return sofar; }
// Error if id is not found std::string get_word(int id) { auto it = id2word_.find(id); CHECK(it != id2word_.end()); return it->second; }
// Algorithm goes as follows: // Clear map // Spawn a vehicle // Set its fuel up to some percentage - remember exact fuel counts that were set here // Drive it for a while, always moving it back to start point every turn to avoid it going off the bubble // When moving back, record the sum of the tiles moved so far // Repeat that for a set number of turns or until all fuel is drained // Compare saved percentage (set before) to current percentage // Rescale the recorded number of tiles based on fuel percentage left // (ie. 0% fuel left means no scaling, 50% fuel left means double the effective distance) // Return the rescaled number long test_efficiency( const vproto_id &veh_id, const ter_id &terrain, int reset_velocity_turn, long target_distance, bool smooth_stops = false ) { long min_dist = target_distance * 0.99; long max_dist = target_distance * 1.01; clear_game( terrain ); const tripoint map_starting_point( 60, 60, 0 ); vehicle *veh_ptr = g->m.add_vehicle( veh_id, map_starting_point, -90, 100, 0 ); REQUIRE( veh_ptr != nullptr ); if( veh_ptr == nullptr ) { return 0; } vehicle &veh = *veh_ptr; // Remove all items from cargo to normalize weight. for( size_t p = 0; p < veh.parts.size(); p++ ) { auto &pt = veh.parts[ p ]; while( veh.remove_item( p, 0 ) ); } const auto &starting_fuel = set_vehicle_fuel( veh, fuel_level ); // This is ugly, but improves accuracy: compare the result of fuel approx function // rather than the amount of fuel we actually requested const float starting_fuel_per = fuel_percentage_left( veh, starting_fuel ); REQUIRE( std::abs( starting_fuel_per - 1.0f ) < 0.001f ); const tripoint starting_point = veh.global_pos3(); veh.tags.insert( "IN_CONTROL_OVERRIDE" ); veh.engine_on = true; veh.cruise_velocity = veh.safe_velocity(); // If we aren't testing repeated cold starts, start the vehicle at cruising velocity. // Otherwise changing the amount of fuel in the tank perturbs the test results. if( reset_velocity_turn == -1 ) { veh.velocity = veh.cruise_velocity; } int reset_counter = 0; long tiles_travelled = 0; int turn_count = 0; int cycles_left = cycle_limit; bool accelerating = true; CHECK( veh.safe_velocity() > 0 ); while( veh.engine_on && veh.safe_velocity() > 0 && cycles_left > 0 ) { cycles_left--; g->m.vehmove(); veh.idle( true ); // If the vehicle starts skidding, the effects become random and test is RUINED REQUIRE( !veh.skidding ); // How much it moved tiles_travelled += square_dist( starting_point, veh.global_pos3() ); // Bring it back to starting point to prevent it from leaving the map const tripoint displacement = starting_point - veh.global_pos3(); tripoint veh_pos = veh.global_pos3(); g->m.displace_vehicle( veh_pos, displacement ); if( reset_velocity_turn < 0 ) { continue; } reset_counter++; if( reset_counter > reset_velocity_turn ) { if( smooth_stops ) { accelerating = !accelerating; veh.cruise_velocity = accelerating ? veh.safe_velocity() : 0; } else { veh.velocity = 0; veh.last_turn = 0; veh.of_turn_carry = 0; } reset_counter = 0; } } float fuel_left = fuel_percentage_left( veh, starting_fuel ); REQUIRE( starting_fuel_per - fuel_left > 0.0001f ); float fuel_percentage_used = fuel_level * ( starting_fuel_per - fuel_left ); long adjusted_tiles_travelled = tiles_travelled / fuel_percentage_used; if( target_distance >= 0 ) { CHECK( adjusted_tiles_travelled >= min_dist ); CHECK( adjusted_tiles_travelled <= max_dist ); } return adjusted_tiles_travelled; }
void* thread_main(void* gm_ptr) { paddle_gradient_machine machine = (paddle_gradient_machine)(gm_ptr); paddle_arguments in_args = paddle_arguments_create_none(); // Create input matrix. paddle_matrix mat = paddle_matrix_create(/* sample_num */ 1, /* size */ 784, /* useGPU */ false); paddle_arguments out_args = paddle_arguments_create_none(); paddle_matrix prob = paddle_matrix_create_none(); for (int iter = 0; iter < NUM_ITER; ++iter) { // There is only one input of this network. CHECK(paddle_arguments_resize(in_args, 1)); paddle_real* array; // Get First row. CHECK(paddle_matrix_get_row(mat, 0, &array)); for (int i = 0; i < 784; ++i) { array[i] = rand() / ((float)RAND_MAX); } CHECK(paddle_arguments_set_value(in_args, 0, mat)); CHECK(paddle_gradient_machine_forward(machine, in_args, out_args, /* isTrain */ false)); CHECK(paddle_arguments_get_value(out_args, 0, prob)); CHECK(paddle_matrix_get_row(prob, 0, &array)); pthread_mutex_lock(&mutex); printf("Prob: "); for (int i = 0; i < 10; ++i) { printf("%.2f ", array[i]); } printf("\n"); pthread_mutex_unlock(&mutex); } CHECK(paddle_matrix_destroy(prob)); CHECK(paddle_arguments_destroy(out_args)); CHECK(paddle_matrix_destroy(mat)); CHECK(paddle_arguments_destroy(in_args)); CHECK(paddle_gradient_machine_destroy(machine)); return NULL; }
void BaseConvolutionLayer<Dtype>::Reshape(const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) { const int first_spatial_axis = channel_axis_ + 1; CHECK_EQ(bottom[0]->num_axes(), first_spatial_axis + num_spatial_axes_) << "bottom num_axes may not change."; num_ = bottom[0]->count(0, channel_axis_); CHECK_EQ(bottom[0]->shape(channel_axis_), channels_) << "Input size incompatible with convolution kernel."; // TODO: generalize to handle inputs of different shapes. for (int bottom_id = 1; bottom_id < bottom.size(); ++bottom_id) { CHECK(bottom[0]->shape() == bottom[bottom_id]->shape()) << "All inputs must have the same shape."; } // Shape the tops. bottom_shape_ = &bottom[0]->shape(); compute_output_shape(); vector<int> top_shape(bottom[0]->shape().begin(), bottom[0]->shape().begin() + channel_axis_); top_shape.push_back(num_output_); for (int i = 0; i < num_spatial_axes_; ++i) { top_shape.push_back(output_shape_[i]); } for (int top_id = 0; top_id < top.size(); ++top_id) { top[top_id]->Reshape(top_shape); } if (reverse_dimensions()) { conv_out_spatial_dim_ = bottom[0]->count(first_spatial_axis); } else { conv_out_spatial_dim_ = top[0]->count(first_spatial_axis); } col_offset_ = kernel_dim_ * conv_out_spatial_dim_; output_offset_ = conv_out_channels_ * conv_out_spatial_dim_ / group_; // Setup input dimensions (conv_input_shape_). vector<int> bottom_dim_blob_shape(1, num_spatial_axes_ + 1); conv_input_shape_.Reshape(bottom_dim_blob_shape); int* conv_input_shape_data = conv_input_shape_.mutable_cpu_data(); for (int i = 0; i < num_spatial_axes_ + 1; ++i) { if (reverse_dimensions()) { conv_input_shape_data[i] = top[0]->shape(channel_axis_ + i); } else { conv_input_shape_data[i] = bottom[0]->shape(channel_axis_ + i); } } // The im2col result buffer will only hold one image at a time to avoid // overly large memory usage. In the special case of 1x1 convolution // it goes lazily unused to save memory. col_buffer_shape_.clear(); col_buffer_shape_.push_back(kernel_dim_ * group_); for (int i = 0; i < num_spatial_axes_; ++i) { if (reverse_dimensions()) { col_buffer_shape_.push_back(input_shape(i + 1)); } else { col_buffer_shape_.push_back(output_shape_[i]); } } col_buffer_.Reshape(col_buffer_shape_); bottom_dim_ = bottom[0]->count(channel_axis_); top_dim_ = top[0]->count(channel_axis_); num_kernels_im2col_ = conv_in_channels_ * conv_out_spatial_dim_; num_kernels_col2im_ = reverse_dimensions() ? top_dim_ : bottom_dim_; // Set up the all ones "bias multiplier" for adding biases by BLAS out_spatial_dim_ = top[0]->count(first_spatial_axis); if (bias_term_) { vector<int> bias_multiplier_shape(1, out_spatial_dim_); bias_multiplier_.Reshape(bias_multiplier_shape); caffe_set(bias_multiplier_.count(), Dtype(1), bias_multiplier_.mutable_cpu_data()); } }
void HTTP2PriorityQueue::Node::removeEnqueuedChild(HTTP2PriorityQueue::Node* node) { CHECK(node->enqueuedHook_.is_linked()); enqueuedChildren_.erase(enqueuedChildren_.iterator_to(*node)); }
ITERATE_LIST(ListHook, hookb, pHook) { CHECK(pHook->parent.getPriority() <= last_prio); last_prio = pHook->parent.getPriority(); }
void HTTP2PriorityQueue::Node::clearPendingEgress() { CHECK(enqueued_); enqueued_ = false; propagatePendingEgressClear(this); }
void DynamicObjectsTest::allTests() { QString dbname = "testdynamic"; Classes::setup(); Classes::addClass( "Test", DynamicObject::createInstance, 0 ); ClassInfo *ci = Classes::classInfo( "Test" ); ci->addObject( "Customer", "Customer_Test", &Customer::createInstance ); ci->addCollection( "Article", "Article_Test" ); PropertyInfo *p; p = new PropertyInfo(); p->setName( "Property1" ); p->setType( QVariant::String ); ci->addProperty( p ); p = new PropertyInfo(); p->setName( "Property2" ); p->setType( QVariant::ULongLong ); ci->addProperty( p ); Classes::setupRelations(); // Drop the database if already exists KProcess *proc = new KProcess; *proc << "dropdb"; *proc << dbname; proc->start(); proc->wait(); delete proc; // Create the database proc = new KProcess; *proc << "createdb"; *proc << dbname; CHECK( proc->start(), true ); proc->wait(); if ( ! proc->normalExit() || proc->exitStatus() != 0 ) { CHECK( true, false ); delete proc; return; } delete proc; QSqlDatabase *db = QSqlDatabase::addDatabase( "QPSQL7" ); db->setDatabaseName( dbname ); db->setUserName( "albert" ); db->setPassword( "" ); db->setHostName( "localhost" ); if ( ! db->open() ) { kdDebug() << "Failed to open database: " << db->lastError().text() << endl; return; } DbBackendIface *backend = new SqlDbBackend( db ); m_manager = new Manager( backend ); m_manager->setMaxObjects( 1 ); m_manager->createSchema(); ObjectRef<Customer> customer = Customer::create(); customer->setCustomerName( "Name of the customer" ); ObjectRef<Article> a1 = Article::create(); a1->setCode( "00001" ); ObjectRef<Article> a2 = Article::create(); a2->setCode( "00002" ); ObjectRef<Object> obj = Classes::classInfo( "Test" )->create(); CHECK( obj->property( "Property1" ).type(), QVariant::String ); CHECK( obj->property( "Property2" ).type(), QVariant::ULongLong ); CHECK( obj->containsObject( "Customer_Test" ), true ); CHECK( obj->containsCollection( "Article_Test" ), true ); obj->setProperty( "Property1", "Property number one" ); obj->setProperty( "Property2", 2 ); CHECK( obj->property( QString( "Property1" ) ).value().toString(), QString( "Property number one" ) ); CHECK( obj->property( QString( "Property2" ) ).value().toULongLong(), 2 ); obj->setObject( "Customer_Test", customer ); obj->collection( "Article_Test" )->add( a1 ); obj->collection( "Article_Test" )->add( a2 ); m_manager->commit(); CHECK( obj->property( "Property1" ).value().toString(), QString( "Property number one" ) ); delete m_manager; }
extern "C" magma_int_t magma_smslice( magma_int_t num_slices, magma_int_t slice, magma_s_matrix A, magma_s_matrix *B, magma_s_matrix *ALOC, magma_s_matrix *ANLOC, magma_index_t *comm_i, float *comm_v, magma_int_t *start, magma_int_t *end, magma_queue_t queue ) { magma_int_t info = 0; if( A.num_rows != A.num_cols ){ printf("%% error: only supported for square matrices.\n"); info = MAGMA_ERR_NOT_SUPPORTED; goto cleanup; } if ( A.memory_location == Magma_CPU && A.storage_type == Magma_CSR ){ CHECK( magma_smconvert( A, B, Magma_CSR, Magma_CSR, queue ) ); magma_free_cpu( B->col ); magma_free_cpu( B->val ); CHECK( magma_smconvert( A, ALOC, Magma_CSR, Magma_CSR, queue ) ); magma_free_cpu( ALOC->col ); magma_free_cpu( ALOC->row ); magma_free_cpu( ALOC->val ); CHECK( magma_smconvert( A, ANLOC, Magma_CSR, Magma_CSR, queue ) ); magma_free_cpu( ANLOC->col ); magma_free_cpu( ANLOC->row ); magma_free_cpu( ANLOC->val ); magma_int_t i,j,k, nnz, nnz_loc=0, loc_row = 0, nnz_nloc = 0; magma_index_t col; magma_int_t size = magma_ceildiv( A.num_rows, num_slices ); magma_int_t lstart = slice*size; magma_int_t lend = min( (slice+1)*size, A.num_rows ); // correct size for last slice size = lend-lstart; CHECK( magma_index_malloc_cpu( &ALOC->row, size+1 ) ); CHECK( magma_index_malloc_cpu( &ANLOC->row, size+1 ) ); // count elements for slice - identity for rest nnz = A.row[ lend ] - A.row[ lstart ] + ( A.num_rows - size ); CHECK( magma_index_malloc_cpu( &B->col, nnz ) ); CHECK( magma_smalloc_cpu( &B->val, nnz ) ); // for the communication plan for( i=0; i<A.num_rows; i++ ) { comm_i[i] = 0; comm_v[i] = MAGMA_S_ZERO; } k=0; B->row[i] = 0; ALOC->row[0] = 0; ANLOC->row[0] = 0; // identity above slice for( i=0; i<lstart; i++ ) { B->row[i+1] = B->row[i]+1; B->val[k] = MAGMA_S_ONE; B->col[k] = i; k++; } // slice for( i=lstart; i<lend; i++ ) { B->row[i+1] = B->row[i] + (A.row[i+1]-A.row[i]); for( j=A.row[i]; j<A.row[i+1]; j++ ){ B->val[k] = A.val[j]; col = A.col[j]; B->col[k] = col; // communication plan if( col<lstart || col>=lend ){ comm_i[ col ] = 1; comm_v[ col ] = comm_v[ col ] + MAGMA_S_MAKE( MAGMA_S_ABS( A.val[j] ), 0.0 ); nnz_nloc++; } else { nnz_loc++; } k++; } loc_row++; ALOC->row[ loc_row ] = nnz_loc; ANLOC->row[ loc_row ] = nnz_nloc; } CHECK( magma_index_malloc_cpu( &ALOC->col, nnz_loc ) ); CHECK( magma_smalloc_cpu( &ALOC->val, nnz_loc ) ); ALOC->num_rows = size; ALOC->num_cols = size; ALOC->nnz = nnz_loc; CHECK( magma_index_malloc_cpu( &ANLOC->col, nnz_nloc ) ); CHECK( magma_smalloc_cpu( &ANLOC->val, nnz_nloc ) ); ANLOC->num_rows = size; ANLOC->num_cols = A.num_cols; ANLOC->nnz = nnz_nloc; nnz_loc = 0; nnz_nloc = 0; // local/nonlocal matrix for( i=lstart; i<lend; i++ ) { for( j=A.row[i]; j<A.row[i+1]; j++ ){ col = A.col[j]; // insert only in local part in ALOC, nonlocal in ANLOC if( col<lstart || col>=lend ){ ANLOC->val[ nnz_nloc ] = A.val[j]; ANLOC->col[ nnz_nloc ] = col; nnz_nloc++; } else { ALOC->val[ nnz_loc ] = A.val[j]; ALOC->col[ nnz_loc ] = col-lstart; nnz_loc++; } } } // identity below slice for( i=lend; i<A.num_rows; i++ ) { B->row[i+1] = B->row[i]+1; B->val[k] = MAGMA_S_ONE; B->col[k] = i; k++; } B->nnz = k; *start = lstart; *end = lend; } else { printf("error: mslice only supported for CSR matrices on the CPU: %d %d.\n", int(A.memory_location), int(A.storage_type) ); info = MAGMA_ERR_NOT_SUPPORTED; } cleanup: return info; }
char File::ReadByte () { std::vector<char> buffer; CHECK(1 == Read(buffer, 1), "Failed to read byte"); return buffer[0]; }
void ImageDataLayer<Dtype>::DataLayerSetUp(const vector<Blob<Dtype>*>& bottom, const vector<Blob<Dtype>*>& top) { const int new_height = this->layer_param_.image_data_param().new_height(); const int new_width = this->layer_param_.image_data_param().new_width(); const bool is_color = this->layer_param_.image_data_param().is_color(); string root_folder = this->layer_param_.image_data_param().root_folder(); CHECK((new_height == 0 && new_width == 0) || (new_height > 0 && new_width > 0)) << "Current implementation requires " "new_height and new_width to be set at the same time."; // Read the file with filenames and labels const string& source = this->layer_param_.image_data_param().source(); LOG(INFO) << "Opening file " << source; std::ifstream infile(source.c_str()); string filename; std::vector<int> vec_label; while (infile >> filename) { for (int label_i = 0; label_i < this->layer_param_.image_data_param().label_size(); ++label_i){ int x; infile >> x; vec_label.push_back(x); } lines_.push_back(std::make_pair(filename, vec_label)); vec_label.clear(); } if (this->layer_param_.image_data_param().shuffle()) { // randomly shuffle data LOG(INFO) << "Shuffling data"; const unsigned int prefetch_rng_seed = caffe_rng_rand(); prefetch_rng_.reset(new Caffe::RNG(prefetch_rng_seed)); ShuffleImages(); } LOG(INFO) << "A total of " << lines_.size() << " images."; lines_id_ = 0; // Check if we would need to randomly skip a few data points if (this->layer_param_.image_data_param().rand_skip()) { unsigned int skip = caffe_rng_rand() % this->layer_param_.image_data_param().rand_skip(); LOG(INFO) << "Skipping first " << skip << " data points."; CHECK_GT(lines_.size(), skip) << "Not enough points to skip"; lines_id_ = skip; } // Read an image, and use it to initialize the top blob. cv::Mat cv_img = ReadImageToCVMat(root_folder + lines_[lines_id_].first, new_height, new_width, is_color); const int channels = cv_img.channels(); const int height = cv_img.rows; const int width = cv_img.cols; // image const int crop_size = this->layer_param_.transform_param().crop_size(); const int batch_size = this->layer_param_.image_data_param().batch_size(); if (crop_size > 0) { top[0]->Reshape(batch_size, channels, crop_size, crop_size); this->prefetch_data_.Reshape(batch_size, channels, crop_size, crop_size); this->transformed_data_.Reshape(1, channels, crop_size, crop_size); } else { top[0]->Reshape(batch_size, channels, height, width); this->prefetch_data_.Reshape(batch_size, channels, height, width); this->transformed_data_.Reshape(1, channels, height, width); } LOG(INFO) << "output data size: " << top[0]->num() << "," << top[0]->channels() << "," << top[0]->height() << "," << top[0]->width(); // label top[1]->Reshape(batch_size, this->layer_param_.image_data_param().label_size(), 1, 1); this->prefetch_label_.Reshape(batch_size, this->layer_param_.image_data_param().label_size(), 1, 1); }
void File::WriteByte (const char byte) { std::vector<char> buffer; buffer.push_back(byte); CHECK(1 == Write(buffer), "Failed to write byte"); }
void ThreadedExecutor::add(Func f) { lock_guard<mutex> lock(mutex_); CHECK(!destructing_); threads_.emplace_back(std::move(f)); }
File::~File() { CHECK(m_File != 0, "File is not opened"); fclose(m_File); }
/* * Handle arp packet */ int handle_arp_packet(ARP_PACKET *arp_packet) { bool addtoarptable = false; char sourmac[18]; //source hardware address const char *sourip = network_display_address(arp_packet->sour_ip); CNET_format_nicaddr(sourmac, arp_packet->sour_mac); printf("ARP packet source MAC: %s \n", sourmac); //handle arp ethernet if (arp_packet->htype == ETH_CODE){ if (arp_packet->hlen == LEN_NICADDR){ if (arp_packet->ptype == IP_CODE){ if (arp_packet->plen == IP_ADDRLEN){ int pos = 0; pos = query_arp_table(arp_packet->sour_ip); if (pos != -1){ printf("Update ARP table - source IP: %s \n", sourip); update_arp_table(arp_packet->sour_mac, pos); addtoarptable = true; } else { printf("Add source IP to ARP table: %s \n", sourip); IPAddr sour_ip = arp_packet->sour_ip; add_arp_table(sour_ip, arp_packet->sour_mac); CHECK(network_unpause_destination(sour_ip)); } if (arp_packet->dest_ip == network_local_address()){ if (!addtoarptable){ printf("Add source IP to ARP table: %s \n", sourip); IPAddr sour_ip = arp_packet->sour_ip; add_arp_table(sour_ip, arp_packet->sour_mac); } if (arp_packet->opcode == ARP_REQUEST_CODE){ CnetNICaddr nicAddress; IPAddr ip1 = 0, ip2 = 0; printf("ARP response IP: %s \n", sourip); arp_packet->opcode = ARP_REPLY_CODE; memcpy(nicAddress, arp_packet->sour_mac, sizeof(CnetNICaddr)); memcpy(arp_packet->sour_mac, linkinfo[1].nicaddr, sizeof(CnetNICaddr)); memcpy(arp_packet->dest_mac, nicAddress, sizeof(CnetNICaddr)); ip1 = arp_packet->sour_ip; ip2 = network_local_address(); arp_packet->sour_ip = ip2; arp_packet->dest_ip = ip1; arp_request(arp_packet); } } } else { printf("IP address length error! (should be equal to 4) \n"); return -1; } } else { printf("Ethernet protocol error! (should be IPv4) \n"); return -1; } } else { printf("MAC address length error! (should be equal to 6) \n"); return -1; } } else { printf("Hardware protocol error! (should be Ethernet) \n"); return -1; } return 0; }
File::File(const std::string & name) { m_File = fopen(name.c_str(), "r+b"); CHECK(m_File != 0, "Failed to open the file"); CHECK(stat(name.c_str(), &m_Stat) == 0, "Could not stat the file"); }
extern "C" magma_int_t magma_z_solver( magma_z_matrix A, magma_z_matrix b, magma_z_matrix *x, magma_zopts *zopts, magma_queue_t queue ) { magma_int_t info = 0; // make sure RHS is a dense matrix if ( b.storage_type != Magma_DENSE ) { printf( "error: sparse RHS not yet supported.\n" ); return MAGMA_ERR_NOT_SUPPORTED; } if( b.num_cols == 1 ){ switch( zopts->solver_par.solver ) { case Magma_CG: CHECK( magma_zcg_res( A, b, x, &zopts->solver_par, queue )); break; case Magma_BICG: CHECK( magma_zbicg( A, b, x, &zopts->solver_par, queue )); break; case Magma_PBICG: CHECK( magma_zpbicg( A, b, x, &zopts->solver_par, &zopts->precond_par, queue )); break; case Magma_CGMERGE: CHECK( magma_zcg_merge( A, b, x, &zopts->solver_par, queue )); break; case Magma_PCG: CHECK( magma_zpcg( A, b, x, &zopts->solver_par, &zopts->precond_par, queue )); break; case Magma_PCGMERGE: CHECK( magma_zpcg_merge( A, b, x, &zopts->solver_par, &zopts->precond_par, queue )); break; case Magma_BICGSTAB: CHECK( magma_zbicgstab( A, b, x, &zopts->solver_par, queue )); break; case Magma_BICGSTABMERGE: CHECK( magma_zbicgstab_merge( A, b, x, &zopts->solver_par, queue )); break; case Magma_PBICGSTABMERGE: CHECK( magma_zpbicgstab_merge( A, b, x, &zopts->solver_par, &zopts->precond_par, queue )); break; case Magma_PBICGSTAB: CHECK( magma_zpbicgstab( A, b, x, &zopts->solver_par, &zopts->precond_par, queue )); break; case Magma_GMRES: CHECK( magma_zfgmres( A, b, x, &zopts->solver_par, &zopts->precond_par, queue )); break; case Magma_PGMRES: CHECK( magma_zfgmres( A, b, x, &zopts->solver_par, &zopts->precond_par, queue )); break; case Magma_IDR: CHECK( magma_zidr( A, b, x, &zopts->solver_par, queue )); break; case Magma_IDRMERGE: CHECK( magma_zidr_merge( A, b, x, &zopts->solver_par, queue )); break; //CHECK( magma_zidr_strms( A, b, x, &zopts->solver_par, queue )); break; case Magma_PIDR: CHECK( magma_zpidr( A, b, x, &zopts->solver_par, &zopts->precond_par, queue )); break; case Magma_PIDRMERGE: //CHECK( magma_zpidr_merge( A, b, x, &zopts->solver_par, &zopts->precond_par, queue )); break; CHECK( magma_zpidr_strms( A, b, x, &zopts->solver_par, &zopts->precond_par, queue )); break; case Magma_LOBPCG: CHECK( magma_zlobpcg( A, &zopts->solver_par, &zopts->precond_par, queue )); break; case Magma_ITERREF: CHECK( magma_ziterref( A, b, x, &zopts->solver_par, &zopts->precond_par, queue )); break; case Magma_JACOBI: CHECK( magma_zjacobi( A, b, x, &zopts->solver_par, queue )); break; case Magma_BAITER: CHECK( magma_zbaiter( A, b, x, &zopts->solver_par, &zopts->precond_par, queue ) ); break; case Magma_BAITERO: CHECK( magma_zbaiter_overlap( A, b, x, &zopts->solver_par, &zopts->precond_par, queue )); break; case Magma_CGS: CHECK( magma_zcgs( A, b, x, &zopts->solver_par, queue ) ); break; case Magma_CGSMERGE: CHECK( magma_zcgs_merge( A, b, x, &zopts->solver_par, queue ) ); break; case Magma_PCGS: CHECK( magma_zpcgs( A, b, x, &zopts->solver_par, &zopts->precond_par, queue ) ); break; case Magma_PCGSMERGE: CHECK( magma_zpcgs_merge( A, b, x, &zopts->solver_par, &zopts->precond_par, queue ) ); break; case Magma_TFQMR: CHECK( magma_ztfqmr( A, b, x, &zopts->solver_par, queue ) ); break; case Magma_PTFQMR: CHECK( magma_zptfqmr( A, b, x, &zopts->solver_par, &zopts->precond_par, queue ) ); break; case Magma_TFQMRMERGE: CHECK( magma_ztfqmr_merge( A, b, x, &zopts->solver_par, queue ) ); break; case Magma_PTFQMRMERGE: CHECK( magma_zptfqmr_merge( A, b, x, &zopts->solver_par, &zopts->precond_par, queue ) ); break; case Magma_QMR: CHECK( magma_zqmr( A, b, x, &zopts->solver_par, queue ) ); break; case Magma_LSQR: CHECK( magma_zlsqr( A, b, x, &zopts->solver_par, &zopts->precond_par, queue ) ); break; case Magma_QMRMERGE: CHECK( magma_zqmr_merge( A, b, x, &zopts->solver_par, queue ) ); break; case Magma_BOMBARD: CHECK( magma_zbombard( A, b, x, &zopts->solver_par, queue ) ); break; case Magma_BOMBARDMERGE: CHECK( magma_zbombard_merge( A, b, x, &zopts->solver_par, queue ) ); break; default: printf("error: solver class not supported.\n"); break; } } else { switch( zopts->solver_par.solver ) { case Magma_CG: CHECK( magma_zbpcg( A, b, x, &zopts->solver_par, &zopts->precond_par, queue )); break; case Magma_PCG: CHECK( magma_zbpcg( A, b, x, &zopts->solver_par, &zopts->precond_par, queue )); break; case Magma_LOBPCG: CHECK( magma_zlobpcg( A, &zopts->solver_par, &zopts->precond_par, queue )); break; default: printf("error: only 1 RHS supported for this solver class.\n"); break; } } cleanup: return info; }
void HTTP2PriorityQueue::Node::addEnqueuedChild(HTTP2PriorityQueue::Node* node) { CHECK(!node->enqueuedHook_.is_linked()); enqueuedChildren_.push_back(*node); }
void t5(int pi) { int BAUD=4800; char *TEXT= "\n\ Now is the winter of our discontent\n\ Made glorious summer by this sun of York;\n\ And all the clouds that lour'd upon our house\n\ In the deep bosom of the ocean buried.\n\ Now are our brows bound with victorious wreaths;\n\ Our bruised arms hung up for monuments;\n\ Our stern alarums changed to merry meetings,\n\ Our dreadful marches to delightful measures.\n\ Grim-visaged war hath smooth'd his wrinkled front;\n\ And now, instead of mounting barded steeds\n\ To fright the souls of fearful adversaries,\n\ He capers nimbly in a lady's chamber\n\ To the lascivious pleasing of a lute.\n\ "; gpioPulse_t wf[] = { {1<<GPIO, 0, 10000}, {0, 1<<GPIO, 30000}, {1<<GPIO, 0, 60000}, {0, 1<<GPIO, 100000}, }; int e, oc, c, wid, id; char text[2048]; printf("Waveforms & serial read/write tests.\n"); id = callback(pi, GPIO, FALLING_EDGE, t5cbf); set_mode(pi, GPIO, PI_OUTPUT); e = wave_clear(pi); CHECK(5, 1, e, 0, 0, "callback, set mode, wave clear"); e = wave_add_generic(pi, 4, wf); CHECK(5, 2, e, 4, 0, "pulse, wave add generic"); wid = wave_create(pi); e = wave_send_repeat(pi, wid); CHECK(5, 3, e, 9, 0, "wave tx repeat"); oc = t5_count; time_sleep(5.05); c = t5_count - oc; CHECK(5, 4, c, 50, 2, "callback"); e = wave_tx_stop(pi); CHECK(5, 5, e, 0, 0, "wave tx stop"); e = bb_serial_read_open(pi, GPIO, BAUD, 8); CHECK(5, 6, e, 0, 0, "serial read open"); wave_clear(pi); e = wave_add_serial(pi, GPIO, BAUD, 8, 2, 5000000, strlen(TEXT), TEXT); CHECK(5, 7, e, 3405, 0, "wave clear, wave add serial"); wid = wave_create(pi); e = wave_send_once(pi, wid); CHECK(5, 8, e, 6811, 0, "wave tx start"); oc = t5_count; time_sleep(3); c = t5_count - oc; CHECK(5, 9, c, 0, 0, "callback"); oc = t5_count; while (wave_tx_busy(pi)) time_sleep(0.1); time_sleep(0.1); c = t5_count - oc; CHECK(5, 10, c, 1702, 0, "wave tx busy, callback"); c = bb_serial_read(pi, GPIO, text, sizeof(text)-1); if (c > 0) text[c] = 0; /* null terminate string */ CHECK(5, 11, strcmp(TEXT, text), 0, 0, "wave tx busy, serial read"); e = bb_serial_read_close(pi, GPIO); CHECK(5, 12, e, 0, 0, "serial read close"); c = wave_get_micros(pi); CHECK(5, 13, c, 6158148, 0, "wave get micros"); c = wave_get_high_micros(pi); if (c > 6158148) c = 6158148; CHECK(5, 14, c, 6158148, 0, "wave get high micros"); c = wave_get_max_micros(pi); CHECK(5, 15, c, 1800000000, 0, "wave get max micros"); c = wave_get_pulses(pi); CHECK(5, 16, c, 3405, 0, "wave get pulses"); c = wave_get_high_pulses(pi); CHECK(5, 17, c, 3405, 0, "wave get high pulses"); c = wave_get_max_pulses(pi); CHECK(5, 18, c, 12000, 0, "wave get max pulses"); c = wave_get_cbs(pi); CHECK(5, 19, c, 6810, 0, "wave get cbs"); c = wave_get_high_cbs(pi); CHECK(5, 20, c, 6810, 0, "wave get high cbs"); c = wave_get_max_cbs(pi); CHECK(5, 21, c, 25016, 0, "wave get max cbs"); callback_cancel(id); }
TEST (Deque, push_front) { Deque<int> d; d.push_front(0); CHECK ( 1 == d.size() ); }