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