int showstp_cmd(const char* brname){
int res;
alloc_args();
set_arg("showmacs");
sprintf(buffer, "%s", brname);
set_arg(buffer);
res = brctl_action(arg_index, args);
free_args();
return res;
}
event exec(command_queue &queue)
{
if(m_count == 0) {
return event();
}
set_arg(m_n_arg, uint_(m_n));
set_arg(m_value_arg, m_value);
return exec_1d(queue, 0, m_count);
}
int delbr_cmd(const char *brname){
printf("DEBUG(BRCTLD):delbr_cmd enter.\n");
int res;
alloc_args();
set_arg("delbr");
sprintf(buffer, "%s", brname);
set_arg(buffer);
res = brctl_action(arg_index, args);
free_args();
printf("DEBUG(BRCTLD):delbr_cmd exit. res:%d.\n",res);
return res;
}
int setageing_cmd(const char* brname,int timer){
printf("DEBUG(BRCTLD):setageing_cmd enter.\n");
int res;
alloc_args();
set_arg("setageing");
sprintf(buffer, "%s", brname);
set_arg(buffer);
sprintf(buffer, "%d", timer);
set_arg(buffer);
res = brctl_action(arg_index, args);
free_args();
printf("DEBUG(BRCTLD):setageing_cmd exit. res:%d.\n",res);
return res;
}
int
ClientApp::parse_args(int argc, ACE_TCHAR* argv[])
{
this->exe_name_ = argv[0];
ACE_Get_Opt get_opts(argc, argv, ACE_TEXT("i:k:n:"));
int c;
while ((c = get_opts()) != -1)
{
int result = 0;
switch (c)
{
case 'i':
this->ior_ = get_opts.opt_arg();
break;
case 'k':
result = set_arg(this->client_kind_,
get_opts.opt_arg(),
c,
"client_kind");
break;
case 'n':
result = set_arg(this->client_id_,
get_opts.opt_arg(),
c,
"client_id");
break;
case '?':
this->usage_statement();
return 1;
default:
this->usage_statement();
return -1;
}
if (result != 0)
{
return result;
}
}
return this->arg_dependency_checks();
}
int lfunc(cons_t *next)
{
cons_t *now;
now = next;
int fc;
fc = get_func(next->cvalue);
if (g_fa[fc].key == NULL) {
printf("syntax error\n");
return 0;
} else {
next = next->cdr;
set_arg(next, g_argl, 0);
int rec = g_fa[fc].rec_num;
g_argl++;
if (rec >= 2) {
rec_cal(fc);
}
now->result = eval(g_fa[fc].exp);
g_argl--;
return now->result;
}
}
void CL_StringFormat::set_arg(int index, long unsigned int value, int min_length)
{
CL_String t = CL_StringHelp::ull_to_text(value);
if ((int) t.length() < min_length)
t = CL_String(min_length-t.length(), '0') + t;
set_arg(index, t);
}
static int fill_args(char **args, char *str)
{
size_t i;
size_t arg_nb;
char *pos[2];
i = ~0lu;
arg_nb = 0;
ft_bzero(pos, sizeof(char *) * 2);
while (str[++i] != '\0')
{
if (str[i] != '"' || ((i > 0 && str[i - 1] == '\\')))
continue ;
if (pos[START] == NULL)
pos[START] = str + i + 1;
else
pos[END] = str + i;
if (pos[START] == NULL || pos[END] == NULL)
continue ;
if (set_arg(&args[arg_nb++], pos[START], pos[END] - pos[START]) < 0)
return arg_nb - 1;
ft_bzero(pos, sizeof(char *) * 2);
}
return arg_nb;
}
static int mat3_set_row(lua_State *L)
{
t_jit_mat3 m;
t_jit_vec3 v;
if(! lua_istable(L, 1))
luaL_error(L, " first argument must be a table");
if(! lua_isnumber(L, 2))
luaL_error(L, " second argument must be a number");
if(! lua_istable(L, 3))
luaL_error(L, " third argument must be a table");
table_to_mat3(L, 1, &m);
table_to_vec3(L, 3, &v);
jit_mat3_set_row(&m, lua_tointeger(L, 2), &v);
mat3_to_table(L, &m);
set_arg(L, 1);
lua_pop(L, 1);
return 0;
}
mkldnn_status_t prepare_reorder(mkldnn_memory_t *user_memory, /** in */
const mkldnn_memory_desc_t *prim_memory_md, /** in */
mkldnn_engine_t prim_engine, /** in: primitive's engine */
int dir_is_user_to_prim, /** in: user -> prim or prim -> user */
mkldnn_memory_t *prim_memory, /** out: primitive's memory created */
mkldnn_primitive_t *reorder, /** out: reorder primitive created */
uint32_t *
net_index, /** primitive index in net (inc if reorder created)
*/
mkldnn_primitive_t *net, args_t *net_args /** net params */) {
const mkldnn_memory_desc_t *user_memory_md;
mkldnn_memory_get_memory_desc(*user_memory, &user_memory_md);
mkldnn_engine_t user_mem_engine;
mkldnn_memory_get_engine(*user_memory, &user_mem_engine);
if (!mkldnn_memory_desc_equal(user_memory_md, prim_memory_md)) {
CHECK(mkldnn_memory_create(prim_memory, prim_memory_md, prim_engine,
MKLDNN_MEMORY_ALLOCATE));
mkldnn_primitive_desc_t reorder_pd;
if (dir_is_user_to_prim) {
CHECK(mkldnn_reorder_primitive_desc_create(&reorder_pd,
user_memory_md, user_mem_engine, prim_memory_md,
prim_engine, NULL));
} else {
CHECK(mkldnn_reorder_primitive_desc_create(&reorder_pd,
prim_memory_md, prim_engine, user_memory_md,
user_mem_engine, NULL));
}
CHECK(mkldnn_primitive_create(reorder, reorder_pd));
CHECK(mkldnn_primitive_desc_destroy(reorder_pd));
net[*net_index] = *reorder;
prepare_arg_node(&net_args[*net_index], 2);
set_arg(&net_args[*net_index].args[0], MKLDNN_ARG_FROM,
dir_is_user_to_prim ? *user_memory : *prim_memory);
set_arg(&net_args[*net_index].args[1], MKLDNN_ARG_TO,
dir_is_user_to_prim ? *prim_memory : *user_memory);
(*net_index)++;
} else {
*prim_memory = NULL;
*reorder = NULL;
}
return mkldnn_success;
}
std::string get_image_identifier(const char *qualifiers, const image2d &image)
{
size_t index = add_arg_with_qualifiers<image2d>(qualifiers, "image");
set_arg(index, image);
return "image";
}
int show_cmd(){
int res;
alloc_args();
set_arg("show");
res = brctl_action(arg_index, args);
free_args();
return res;
}
void set_arg(cons_t *arg_value,int layer, int arg_num)
{
int ans;
if (arg_value != NULL) {
ans = get_value(arg_value);
arg_num++;
set_arg(arg_value->cdr, layer, arg_num);
g_arga[layer + 1][arg_num - 1] = ans;
}
}
event exec(command_queue &queue)
{
if(m_count == 0){
// nothing to do
return event();
}
size_t global_work_size = calculate_work_size(m_count, m_vpt, m_tpb);
set_arg(m_count_arg, uint_(m_count));
return exec_1d(queue, 0, global_work_size, m_tpb);
}
model::model(init_arg *args)
{
arma::arma_rng::set_seed_random();
check_arg(*args);
set_arg(args);
training_mean = make_unique<vec_t>(NUM_TRAINING_DATA, arma::fill::zeros);
training_cov = make_unique<mat_t>(NUM_TRAINING_DATA, NUM_TRAINING_DATA, arma::fill::zeros);
chol_cov = make_unique<mat_t>(NUM_TRAINING_DATA, NUM_TRAINING_DATA, arma::fill::zeros);
mixture_cov = make_unique<vec_t>(NUM_TRAINING_DATA, arma::fill::zeros);
testing_cov = make_unique<vec_t>(1, arma::fill::zeros);
alpha = make_unique<vec_t>(NUM_TRAINING_DATA, arma::fill::zeros);
v = make_unique<vec_t>(NUM_TRAINING_DATA, arma::fill::zeros);
testing_target = make_unique<vec_t>(NUM_TESTING_DATA, arma::fill::zeros);
testing_var = make_unique<vec_t>(NUM_TESTING_DATA, arma::fill::zeros);
}
int rfunc(cons_t *next)
{
cons_t *now;
now = next;
next = next->cdr;
set_arg(next, g_argl);
g_argl++;
now->result = eval(g_fa[now->ivalue].exp);
g_argl--;
return now->result;
}
static int mat4_negate(lua_State *L)
{
t_jit_mat4 m;
if(! lua_istable(L, 1))
luaL_error(L, "first argument must be a table");
table_to_mat4(L, 1, &m);
jit_mat4_negate(&m);
mat4_to_table(L, &m);
set_arg(L, 1);
lua_pop(L, 1);
return 0;
}
void agent_act(unsigned char * img_bytes, int img_width, int img_height, bool_t img_is_belly, int pass_button,
navdata_unpacked_t * navdata, commands_t * commands)
{
int k = 0;
PyObject *pImageBytes = PyByteArray_FromStringAndSize((const char *)img_bytes, img_width*img_height*3);
set_arg(pImageBytes, k++);
set_int_arg(img_width, k++);
set_int_arg(img_height, k++);
set_int_arg(img_is_belly?1:0, k++);
set_int_arg(pass_button, k++);
navdata_demo_t demo = navdata->navdata_demo;
set_int_arg(demo.ctrl_state, k++);
set_int_arg(demo.vbat_flying_percentage, k++);
set_float_arg(demo.theta, k++);
set_float_arg(demo.phi, k++);
set_float_arg(demo.psi, k++);
set_int_arg(navdata->navdata_altitude.altitude_raw, k++);
navdata_vision_raw_t vision_raw = navdata->navdata_vision_raw;
set_float_arg(vision_raw.vision_tx_raw, k++);
set_float_arg(vision_raw.vision_ty_raw, k++);
PyObject * pResult = PyObject_CallObject(pFunc, pArgs);
if (!pResult)
{
fun_error("Call failed\n", "");
}
k = 0;
commands->zap = get_int_result(pResult, k++);
commands->phi = get_float_result(pResult, k++);
commands->theta = get_float_result(pResult, k++);
commands->gaz = get_float_result(pResult, k++);
commands->yaw = get_float_result(pResult, k++);
}
static int mat4_set_translation(lua_State *L)
{
t_jit_mat4 m;
t_jit_vec3 v;
if(! lua_istable(L, 1))
luaL_error(L, "first argument must be a table");
if(! lua_istable(L, 1))
luaL_error(L, "second argument must be a table");
table_to_mat4(L, 1, &m);
table_to_vec3(L, 1, &v);
jit_mat4_set_translation(&m, &v);
mat4_to_table(L, &m);
set_arg(L, 1);
lua_pop(L, 1);
return 0;
}
int lfunc(cons_t *next)
{
cons_t *now;
now = next;
int fc;
fc = getfunc(next->cvalue);
if (g_fa[fc].key == NULL) {
printf("syntax error\n");
return 0;
} else {
next = next->cdr;
set_arg(next, g_argl);
g_argl++;
now->result = eval(g_fa[fc].exp);
g_argl--;
return now->result;
}
}
static int
parse_args(PGP_Context *ctx, uint8 *args, int arg_len,
struct debug_expect * ex)
{
char *str = downcase_convert(args, arg_len);
char *key,
*val;
int key_len,
val_len;
int res = 0;
char *p = str;
while (*p)
{
res = PXE_ARGUMENT_ERROR;
p = getword(p, &key, &key_len);
if (*p++ != '=')
break;
p = getword(p, &val, &val_len);
if (*p == '\0')
;
else if (*p++ != ',')
break;
if (*key == 0 || *val == 0 || val_len == 0)
break;
key[key_len] = 0;
val[val_len] = 0;
res = set_arg(ctx, key, val, ex);
if (res < 0)
break;
}
pfree(str);
return res;
}
static void set_float_arg(float val, int pos)
{
set_arg(PyFloat_FromDouble((double)val), pos);
}
mkldnn_status_t simple_net() {
mkldnn_engine_t engine;
CHECK(mkldnn_engine_create(&engine, mkldnn_cpu, 0 /* idx */));
/* build a simple net */
uint32_t n_fwd = 0, n_bwd = 0;
mkldnn_primitive_t net_fwd[10], net_bwd[10];
args_t net_fwd_args[10], net_bwd_args[10];
mkldnn_dim_t net_src_sizes[4] = { BATCH, IC, CONV_IH, CONV_IW };
mkldnn_dim_t net_dst_sizes[4] = { BATCH, OC, POOL_OH, POOL_OW };
float *net_src = (float *)malloc(product(net_src_sizes, 4) * sizeof(float));
float *net_dst = (float *)malloc(product(net_dst_sizes, 4) * sizeof(float));
init_net_data(net_src, 4, net_src_sizes);
memset(net_dst, 0, product(net_dst_sizes, 4) * sizeof(float));
/*----------------------------------------------------------------------*/
/*----------------- Forward Stream -------------------------------------*/
/* AlexNet: conv
* {BATCH, IC, CONV_IH, CONV_IW} (x) {OC, IC, 11, 11} ->
* {BATCH, OC, CONV_OH, CONV_OW}
* strides: {CONV_STRIDE, CONV_STRIDE}
*/
mkldnn_dim_t *conv_user_src_sizes = net_src_sizes;
mkldnn_dim_t conv_user_weights_sizes[4] = { OC, IC, 11, 11 };
mkldnn_dim_t conv_bias_sizes[4] = { OC };
mkldnn_dim_t conv_user_dst_sizes[4] = { BATCH, OC, CONV_OH, CONV_OW };
mkldnn_dim_t conv_strides[2] = { CONV_STRIDE, CONV_STRIDE };
mkldnn_dim_t conv_padding[2] = { CONV_PAD, CONV_PAD };
float *conv_src = net_src;
float *conv_weights = (float *)malloc(
product(conv_user_weights_sizes, 4) * sizeof(float));
float *conv_bias
= (float *)malloc(product(conv_bias_sizes, 1) * sizeof(float));
init_net_data(conv_weights, 4, conv_user_weights_sizes);
init_net_data(conv_bias, 1, conv_bias_sizes);
/* create memory for user data */
mkldnn_memory_t conv_user_src_memory, conv_user_weights_memory,
conv_user_bias_memory;
init_data_memory(4, conv_user_src_sizes, mkldnn_nchw, mkldnn_f32, engine,
conv_src, &conv_user_src_memory);
init_data_memory(4, conv_user_weights_sizes, mkldnn_oihw, mkldnn_f32,
engine, conv_weights, &conv_user_weights_memory);
init_data_memory(1, conv_bias_sizes, mkldnn_x, mkldnn_f32, engine,
conv_bias, &conv_user_bias_memory);
/* create a convolution */
mkldnn_primitive_desc_t conv_pd;
{
/* create data descriptors for convolution w/ no specified format */
mkldnn_memory_desc_t conv_src_md, conv_weights_md, conv_bias_md,
conv_dst_md;
CHECK(mkldnn_memory_desc_init_by_tag(&conv_src_md, 4,
conv_user_src_sizes, mkldnn_f32, mkldnn_format_tag_any));
CHECK(mkldnn_memory_desc_init_by_tag(&conv_weights_md, 4,
conv_user_weights_sizes, mkldnn_f32, mkldnn_format_tag_any));
CHECK(mkldnn_memory_desc_init_by_tag(
&conv_bias_md, 1, conv_bias_sizes, mkldnn_f32, mkldnn_x));
CHECK(mkldnn_memory_desc_init_by_tag(&conv_dst_md, 4,
conv_user_dst_sizes, mkldnn_f32, mkldnn_format_tag_any));
mkldnn_convolution_desc_t conv_any_desc;
CHECK(mkldnn_convolution_forward_desc_init(&conv_any_desc,
mkldnn_forward, mkldnn_convolution_direct, &conv_src_md,
&conv_weights_md, &conv_bias_md, &conv_dst_md, conv_strides,
conv_padding, conv_padding, mkldnn_padding_zero));
CHECK(mkldnn_primitive_desc_create(
&conv_pd, &conv_any_desc, NULL, engine, NULL));
}
mkldnn_memory_t conv_internal_src_memory, conv_internal_weights_memory,
conv_internal_dst_memory;
/* create memory for dst data, we don't need to reorder it to user data */
const mkldnn_memory_desc_t *conv_dst_md
= mkldnn_primitive_desc_query_md(conv_pd, mkldnn_query_dst_md, 0);
CHECK(mkldnn_memory_create(&conv_internal_dst_memory, conv_dst_md, engine,
MKLDNN_MEMORY_ALLOCATE));
/* create reorder primitives between user data and convolution srcs
* if required */
mkldnn_primitive_t conv_reorder_src, conv_reorder_weights;
const mkldnn_memory_desc_t *conv_src_md
= mkldnn_primitive_desc_query_md(conv_pd, mkldnn_query_src_md, 0);
CHECK(prepare_reorder(&conv_user_src_memory, conv_src_md, engine, 1,
&conv_internal_src_memory, &conv_reorder_src, &n_fwd, net_fwd,
net_fwd_args));
const mkldnn_memory_desc_t *conv_weights_md
= mkldnn_primitive_desc_query_md(
conv_pd, mkldnn_query_weights_md, 0);
CHECK(prepare_reorder(&conv_user_weights_memory, conv_weights_md, engine, 1,
&conv_internal_weights_memory, &conv_reorder_weights, &n_fwd,
net_fwd, net_fwd_args));
mkldnn_memory_t conv_src_memory = conv_internal_src_memory ?
conv_internal_src_memory :
conv_user_src_memory;
mkldnn_memory_t conv_weights_memory = conv_internal_weights_memory ?
conv_internal_weights_memory :
conv_user_weights_memory;
/* finally create a convolution primitive */
mkldnn_primitive_t conv;
CHECK(mkldnn_primitive_create(&conv, conv_pd));
net_fwd[n_fwd] = conv;
prepare_arg_node(&net_fwd_args[n_fwd], 4);
set_arg(&net_fwd_args[n_fwd].args[0], MKLDNN_ARG_SRC, conv_src_memory);
set_arg(&net_fwd_args[n_fwd].args[1], MKLDNN_ARG_WEIGHTS,
conv_weights_memory);
set_arg(&net_fwd_args[n_fwd].args[2], MKLDNN_ARG_BIAS,
conv_user_bias_memory);
set_arg(&net_fwd_args[n_fwd].args[3], MKLDNN_ARG_DST,
conv_internal_dst_memory);
n_fwd++;
/* AlexNet: relu
* {BATCH, OC, CONV_OH, CONV_OW} -> {BATCH, OC, CONV_OH, CONV_OW}
*/
float negative_slope = 1.0f;
/* keep memory format of source same as the format of convolution
* output in order to avoid reorder */
const mkldnn_memory_desc_t *relu_src_md = conv_dst_md;
/* create a relu primitive descriptor */
mkldnn_eltwise_desc_t relu_desc;
CHECK(mkldnn_eltwise_forward_desc_init(&relu_desc, mkldnn_forward,
mkldnn_eltwise_relu, relu_src_md, negative_slope, 0));
mkldnn_primitive_desc_t relu_pd;
CHECK(mkldnn_primitive_desc_create(
&relu_pd, &relu_desc, NULL, engine, NULL));
/* create relu dst memory */
mkldnn_memory_t relu_dst_memory;
const mkldnn_memory_desc_t *relu_dst_md
= mkldnn_primitive_desc_query_md(relu_pd, mkldnn_query_dst_md, 0);
CHECK(mkldnn_memory_create(&relu_dst_memory, relu_dst_md, engine,
MKLDNN_MEMORY_ALLOCATE));
/* finally create a relu primitive */
mkldnn_primitive_t relu;
CHECK(mkldnn_primitive_create(&relu, relu_pd));
net_fwd[n_fwd] = relu;
prepare_arg_node(&net_fwd_args[n_fwd], 2);
set_arg(&net_fwd_args[n_fwd].args[0], MKLDNN_ARG_SRC,
conv_internal_dst_memory);
set_arg(&net_fwd_args[n_fwd].args[1], MKLDNN_ARG_DST, relu_dst_memory);
n_fwd++;
/* AlexNet: lrn
* {BATCH, OC, CONV_OH, CONV_OW} -> {BATCH, OC, CONV_OH, CONV_OW}
* local size: 5
* alpha: 0.0001
* beta: 0.75
* k: 1.0
*/
uint32_t local_size = 5;
float alpha = 0.0001f;
float beta = 0.75f;
float k = 1.0f;
/* create lrn src memory descriptor using dst memory descriptor
* from previous primitive */
const mkldnn_memory_desc_t *lrn_src_md = relu_dst_md;
/* create a lrn primitive descriptor */
mkldnn_lrn_desc_t lrn_desc;
CHECK(mkldnn_lrn_forward_desc_init(&lrn_desc, mkldnn_forward,
mkldnn_lrn_across_channels, lrn_src_md, local_size, alpha, beta,
k));
mkldnn_primitive_desc_t lrn_pd;
CHECK(mkldnn_primitive_desc_create(&lrn_pd, &lrn_desc, NULL, engine, NULL));
/* create primitives for lrn dst and workspace memory */
mkldnn_memory_t lrn_dst_memory, lrn_ws_memory;
const mkldnn_memory_desc_t *lrn_dst_md
= mkldnn_primitive_desc_query_md(lrn_pd, mkldnn_query_dst_md, 0);
CHECK(mkldnn_memory_create(&lrn_dst_memory, lrn_dst_md, engine,
MKLDNN_MEMORY_ALLOCATE));
/* create workspace only in training and only for forward primitive*/
/* query lrn_pd for workspace, this memory will be shared with forward lrn*/
const mkldnn_memory_desc_t *lrn_ws_md = mkldnn_primitive_desc_query_md(
lrn_pd, mkldnn_query_workspace_md, 0);
CHECK(mkldnn_memory_create(
&lrn_ws_memory, lrn_ws_md, engine, MKLDNN_MEMORY_ALLOCATE));
/* finally create a lrn primitive */
mkldnn_primitive_t lrn;
CHECK(mkldnn_primitive_create(&lrn, lrn_pd));
net_fwd[n_fwd] = lrn;
prepare_arg_node(&net_fwd_args[n_fwd], 3);
set_arg(&net_fwd_args[n_fwd].args[0], MKLDNN_ARG_SRC, relu_dst_memory);
set_arg(&net_fwd_args[n_fwd].args[1], MKLDNN_ARG_DST, lrn_dst_memory);
set_arg(&net_fwd_args[n_fwd].args[2], MKLDNN_ARG_WORKSPACE, lrn_ws_memory);
n_fwd++;
/* AlexNet: pool
* {BATCH, OC, CONV_OH, CONV_OW} -> {BATCH, OC, POOL_OH, POOL_OW}
* kernel: {3, 3}
* strides: {POOL_STRIDE, POOL_STRIDE}
*/
mkldnn_dim_t *pool_dst_sizes = net_dst_sizes;
mkldnn_dim_t pool_kernel[2] = { 3, 3 };
mkldnn_dim_t pool_strides[2] = { POOL_STRIDE, POOL_STRIDE };
mkldnn_dim_t pool_padding[2] = { POOL_PAD, POOL_PAD };
/* create memory for user dst data */
mkldnn_memory_t pool_user_dst_memory;
init_data_memory(4, pool_dst_sizes, mkldnn_nchw, mkldnn_f32, engine,
net_dst, &pool_user_dst_memory);
/* create a pooling primitive descriptor */
mkldnn_primitive_desc_t pool_pd;
{
/* create pooling src memory descriptor using dst descriptor
* from previous primitive */
const mkldnn_memory_desc_t *pool_src_md = lrn_dst_md;
/* create descriptors for dst pooling data */
mkldnn_memory_desc_t pool_dst_md;
CHECK(mkldnn_memory_desc_init_by_tag(&pool_dst_md, 4, pool_dst_sizes,
mkldnn_f32, mkldnn_format_tag_any));
mkldnn_pooling_desc_t pool_desc;
CHECK(mkldnn_pooling_forward_desc_init(&pool_desc, mkldnn_forward,
mkldnn_pooling_max, pool_src_md, &pool_dst_md, pool_strides,
pool_kernel, pool_padding, pool_padding, mkldnn_padding_zero));
CHECK(mkldnn_primitive_desc_create(
&pool_pd, &pool_desc, NULL, engine, NULL));
}
/* create memory for workspace */
mkldnn_memory_t pool_ws_memory;
const mkldnn_memory_desc_t *pool_ws_md = mkldnn_primitive_desc_query_md(
pool_pd, mkldnn_query_workspace_md, 0);
CHECK(mkldnn_memory_create(&pool_ws_memory, pool_ws_md, engine,
MKLDNN_MEMORY_ALLOCATE));
/* create reorder primitives between pooling dsts and user format dst
* if required */
mkldnn_primitive_t pool_reorder_dst;
mkldnn_memory_t pool_internal_dst_memory;
const mkldnn_memory_desc_t *pool_dst_md
= mkldnn_primitive_desc_query_md(pool_pd, mkldnn_query_dst_md, 0);
n_fwd += 1; /* tentative workaround: preserve space for pooling that should
happen before the reorder */
CHECK(prepare_reorder(&pool_user_dst_memory, pool_dst_md, engine, 0,
&pool_internal_dst_memory, &pool_reorder_dst, &n_fwd, net_fwd,
net_fwd_args));
n_fwd -= pool_reorder_dst ? 2 : 1;
mkldnn_memory_t pool_dst_memory = pool_internal_dst_memory ?
pool_internal_dst_memory :
pool_user_dst_memory;
/* finally create a pooling primitive */
mkldnn_primitive_t pool;
CHECK(mkldnn_primitive_create(&pool, pool_pd));
net_fwd[n_fwd] = pool;
prepare_arg_node(&net_fwd_args[n_fwd], 3);
set_arg(&net_fwd_args[n_fwd].args[0], MKLDNN_ARG_SRC, lrn_dst_memory);
set_arg(&net_fwd_args[n_fwd].args[1], MKLDNN_ARG_DST, pool_dst_memory);
set_arg(&net_fwd_args[n_fwd].args[2], MKLDNN_ARG_WORKSPACE, pool_ws_memory);
n_fwd++;
if (pool_reorder_dst)
n_fwd += 1;
/*-----------------------------------------------------------------------*/
/*----------------- Backward Stream -------------------------------------*/
/*-----------------------------------------------------------------------*/
/* ... user diff_data ...*/
float *net_diff_dst
= (float *)malloc(product(pool_dst_sizes, 4) * sizeof(float));
init_net_data(net_diff_dst, 4, pool_dst_sizes);
/* create memory for user diff dst data*/
mkldnn_memory_t pool_user_diff_dst_memory;
init_data_memory(4, pool_dst_sizes, mkldnn_nchw, mkldnn_f32, engine,
net_diff_dst, &pool_user_diff_dst_memory);
/* Pooling Backward */
/* pooling diff src memory descriptor */
const mkldnn_memory_desc_t *pool_diff_src_md = lrn_dst_md;
/* pooling diff dst memory descriptor */
const mkldnn_memory_desc_t *pool_diff_dst_md = pool_dst_md;
/* create backward pooling descriptor */
mkldnn_pooling_desc_t pool_bwd_desc;
CHECK(mkldnn_pooling_backward_desc_init(&pool_bwd_desc, mkldnn_pooling_max,
pool_diff_src_md, pool_diff_dst_md, pool_strides, pool_kernel,
pool_padding, pool_padding, mkldnn_padding_zero));
/* backward primitive descriptor needs to hint forward descriptor*/
mkldnn_primitive_desc_t pool_bwd_pd;
CHECK(mkldnn_primitive_desc_create(
&pool_bwd_pd, &pool_bwd_desc, NULL, engine, pool_pd));
/* create reorder primitive between user diff dst and pool diff dst
* if required*/
mkldnn_memory_t pool_diff_dst_memory, pool_internal_diff_dst_memory;
mkldnn_primitive_t pool_reorder_diff_dst;
CHECK(prepare_reorder(&pool_user_diff_dst_memory, pool_diff_dst_md, engine,
1, &pool_internal_diff_dst_memory, &pool_reorder_diff_dst, &n_bwd,
net_bwd, net_bwd_args));
pool_diff_dst_memory = pool_internal_diff_dst_memory ?
pool_internal_diff_dst_memory :
pool_user_diff_dst_memory;
/* create memory for pool diff src data */
mkldnn_memory_t pool_diff_src_memory;
CHECK(mkldnn_memory_create(&pool_diff_src_memory, pool_diff_src_md, engine,
MKLDNN_MEMORY_ALLOCATE));
/* finally create backward pooling primitive */
mkldnn_primitive_t pool_bwd;
CHECK(mkldnn_primitive_create(&pool_bwd, pool_bwd_pd));
net_bwd[n_bwd] = pool_bwd;
prepare_arg_node(&net_bwd_args[n_bwd], 3);
set_arg(&net_bwd_args[n_bwd].args[0], MKLDNN_ARG_DIFF_DST,
pool_diff_dst_memory);
set_arg(&net_bwd_args[n_bwd].args[1], MKLDNN_ARG_WORKSPACE, pool_ws_memory);
set_arg(&net_bwd_args[n_bwd].args[2], MKLDNN_ARG_DIFF_SRC,
pool_diff_src_memory);
n_bwd++;
/* Backward lrn */
const mkldnn_memory_desc_t *lrn_diff_dst_md = pool_diff_src_md;
/* create backward lrn descriptor */
mkldnn_lrn_desc_t lrn_bwd_desc;
CHECK(mkldnn_lrn_backward_desc_init(&lrn_bwd_desc,
mkldnn_lrn_across_channels, lrn_src_md, lrn_diff_dst_md, local_size,
alpha, beta, k));
mkldnn_primitive_desc_t lrn_bwd_pd;
CHECK(mkldnn_primitive_desc_create(
&lrn_bwd_pd, &lrn_bwd_desc, NULL, engine, lrn_pd));
/* create memory for lrn diff src */
mkldnn_memory_t lrn_diff_src_memory;
const mkldnn_memory_desc_t *lrn_diff_src_md
= mkldnn_primitive_desc_query_md(
lrn_bwd_pd, mkldnn_query_diff_src_md, 0);
CHECK(mkldnn_memory_create(&lrn_diff_src_memory, lrn_diff_src_md, engine,
MKLDNN_MEMORY_ALLOCATE));
/* finally create backward lrn primitive */
mkldnn_primitive_t lrn_bwd;
CHECK(mkldnn_primitive_create(&lrn_bwd, lrn_bwd_pd));
net_bwd[n_bwd] = lrn_bwd;
prepare_arg_node(&net_bwd_args[n_bwd], 4);
set_arg(&net_bwd_args[n_bwd].args[0], MKLDNN_ARG_SRC, relu_dst_memory);
set_arg(&net_bwd_args[n_bwd].args[1], MKLDNN_ARG_DIFF_DST,
pool_diff_src_memory);
set_arg(&net_bwd_args[n_bwd].args[2], MKLDNN_ARG_WORKSPACE, lrn_ws_memory);
set_arg(&net_bwd_args[n_bwd].args[3], MKLDNN_ARG_DIFF_SRC,
lrn_diff_src_memory);
n_bwd++;
/* Backward relu */
const mkldnn_memory_desc_t *relu_diff_dst_md = lrn_diff_src_md;
/* create backward relu descriptor */
mkldnn_eltwise_desc_t relu_bwd_desc;
CHECK(mkldnn_eltwise_backward_desc_init(&relu_bwd_desc, mkldnn_eltwise_relu,
relu_diff_dst_md, relu_src_md, negative_slope, 0));
mkldnn_primitive_desc_t relu_bwd_pd;
CHECK(mkldnn_primitive_desc_create(
&relu_bwd_pd, &relu_bwd_desc, NULL, engine, relu_pd));
/* create memory for relu diff src */
mkldnn_memory_t relu_diff_src_memory;
const mkldnn_memory_desc_t *relu_diff_src_md
= mkldnn_primitive_desc_query_md(
relu_bwd_pd, mkldnn_query_diff_src_md, 0);
CHECK(mkldnn_memory_create(&relu_diff_src_memory, relu_diff_src_md, engine,
MKLDNN_MEMORY_ALLOCATE));
/* finally create backward relu primitive */
mkldnn_primitive_t relu_bwd;
CHECK(mkldnn_primitive_create(&relu_bwd, relu_bwd_pd));
net_bwd[n_bwd] = relu_bwd;
prepare_arg_node(&net_bwd_args[n_bwd], 3);
set_arg(&net_bwd_args[n_bwd].args[0], MKLDNN_ARG_SRC,
conv_internal_dst_memory);
set_arg(&net_bwd_args[n_bwd].args[1], MKLDNN_ARG_DIFF_DST,
lrn_diff_src_memory);
set_arg(&net_bwd_args[n_bwd].args[2], MKLDNN_ARG_DIFF_SRC,
relu_diff_src_memory);
n_bwd++;
/* Backward convolution with respect to weights */
float *conv_diff_bias_buffer
= (float *)malloc(product(conv_bias_sizes, 1) * sizeof(float));
float *conv_user_diff_weights_buffer = (float *)malloc(
product(conv_user_weights_sizes, 4) * sizeof(float));
/* initialize memory for diff weights in user format */
mkldnn_memory_t conv_user_diff_weights_memory;
init_data_memory(4, conv_user_weights_sizes, mkldnn_oihw, mkldnn_f32,
engine, conv_user_diff_weights_buffer,
&conv_user_diff_weights_memory);
/* create backward convolution primitive descriptor */
mkldnn_primitive_desc_t conv_bwd_weights_pd;
{
/* memory descriptors should be in format `any` to allow backward
* convolution for
* weights to chose the format it prefers for best performance */
mkldnn_memory_desc_t conv_diff_src_md, conv_diff_weights_md,
conv_diff_bias_md, conv_diff_dst_md;
CHECK(mkldnn_memory_desc_init_by_tag(&conv_diff_src_md, 4,
conv_user_src_sizes, mkldnn_f32, mkldnn_format_tag_any));
CHECK(mkldnn_memory_desc_init_by_tag(&conv_diff_weights_md, 4,
conv_user_weights_sizes, mkldnn_f32, mkldnn_format_tag_any));
CHECK(mkldnn_memory_desc_init_by_tag(
&conv_diff_bias_md, 1, conv_bias_sizes, mkldnn_f32, mkldnn_x));
CHECK(mkldnn_memory_desc_init_by_tag(&conv_diff_dst_md, 4,
conv_user_dst_sizes, mkldnn_f32, mkldnn_format_tag_any));
/* create backward convolution descriptor */
mkldnn_convolution_desc_t conv_bwd_weights_desc;
CHECK(mkldnn_convolution_backward_weights_desc_init(
&conv_bwd_weights_desc, mkldnn_convolution_direct,
&conv_diff_src_md, &conv_diff_weights_md, &conv_diff_bias_md,
&conv_diff_dst_md, conv_strides, conv_padding, conv_padding,
mkldnn_padding_zero));
CHECK(mkldnn_primitive_desc_create(&conv_bwd_weights_pd,
&conv_bwd_weights_desc, NULL, engine, conv_pd));
}
/* for best performance convolution backward might chose
* different memory format for src and diff_dst
* than the memory formats preferred by forward convolution
* for src and dst respectively */
/* create reorder primitives for src from forward convolution to the
* format chosen by backward convolution */
mkldnn_primitive_t conv_bwd_reorder_src;
mkldnn_memory_t conv_bwd_internal_src_memory;
const mkldnn_memory_desc_t *conv_diff_src_md
= mkldnn_primitive_desc_query_md(
conv_bwd_weights_pd, mkldnn_query_src_md, 0);
CHECK(prepare_reorder(&conv_src_memory, conv_diff_src_md, engine, 1,
&conv_bwd_internal_src_memory, &conv_bwd_reorder_src, &n_bwd,
net_bwd, net_bwd_args));
mkldnn_memory_t conv_bwd_weights_src_memory = conv_bwd_internal_src_memory ?
conv_bwd_internal_src_memory :
conv_src_memory;
/* create reorder primitives for diff_dst between diff_src from relu_bwd
* and format preferred by conv_diff_weights */
mkldnn_primitive_t conv_reorder_diff_dst;
mkldnn_memory_t conv_internal_diff_dst_memory;
const mkldnn_memory_desc_t *conv_diff_dst_md
= mkldnn_primitive_desc_query_md(
conv_bwd_weights_pd, mkldnn_query_diff_dst_md, 0);
CHECK(prepare_reorder(&relu_diff_src_memory, conv_diff_dst_md, engine, 1,
&conv_internal_diff_dst_memory, &conv_reorder_diff_dst, &n_bwd,
net_bwd, net_bwd_args));
mkldnn_memory_t conv_diff_dst_memory = conv_internal_diff_dst_memory ?
conv_internal_diff_dst_memory :
relu_diff_src_memory;
/* create reorder primitives for conv diff weights memory */
mkldnn_primitive_t conv_reorder_diff_weights;
mkldnn_memory_t conv_internal_diff_weights_memory;
const mkldnn_memory_desc_t *conv_diff_weights_md
= mkldnn_primitive_desc_query_md(
conv_bwd_weights_pd, mkldnn_query_diff_weights_md, 0);
n_bwd += 1; /* tentative workaround: preserve space for conv_bwd_weights
that should happen before the reorder
*/
CHECK(prepare_reorder(&conv_user_diff_weights_memory, conv_diff_weights_md,
engine, 0, &conv_internal_diff_weights_memory,
&conv_reorder_diff_weights, &n_bwd, net_bwd, net_bwd_args));
n_bwd -= conv_reorder_diff_weights ? 2 : 1;
mkldnn_memory_t conv_diff_weights_memory
= conv_internal_diff_weights_memory ?
conv_internal_diff_weights_memory :
conv_user_diff_weights_memory;
/* create memory for diff bias memory */
mkldnn_memory_t conv_diff_bias_memory;
const mkldnn_memory_desc_t *conv_diff_bias_md
= mkldnn_primitive_desc_query_md(
conv_bwd_weights_pd, mkldnn_query_diff_weights_md, 1);
CHECK(mkldnn_memory_create(
&conv_diff_bias_memory, conv_diff_bias_md, engine, NULL));
CHECK(mkldnn_memory_set_data_handle(
conv_diff_bias_memory, conv_diff_bias_buffer));
/* finally created backward convolution weights primitive */
mkldnn_primitive_t conv_bwd_weights;
CHECK(mkldnn_primitive_create(&conv_bwd_weights, conv_bwd_weights_pd));
net_bwd[n_bwd] = conv_bwd_weights;
prepare_arg_node(&net_bwd_args[n_bwd], 4);
set_arg(&net_bwd_args[n_bwd].args[0], MKLDNN_ARG_SRC,
conv_bwd_weights_src_memory);
set_arg(&net_bwd_args[n_bwd].args[1], MKLDNN_ARG_DIFF_DST,
conv_diff_dst_memory);
set_arg(&net_bwd_args[n_bwd].args[2], MKLDNN_ARG_DIFF_WEIGHTS,
conv_diff_weights_memory);
set_arg(&net_bwd_args[n_bwd].args[3], MKLDNN_ARG_DIFF_BIAS,
conv_diff_bias_memory);
n_bwd++;
if (conv_reorder_diff_weights)
n_bwd += 1;
// output from backward stream
void *net_diff_weights = NULL;
void *net_diff_bias = NULL;
int n_iter = 10; // number of iterations for training.
mkldnn_stream_t stream;
CHECK(mkldnn_stream_create(&stream, engine, mkldnn_stream_default_flags));
/* Execute the net */
for (int i = 0; i < n_iter; i++) {
for (uint32_t i = 0; i < n_fwd; ++i)
CHECK(mkldnn_primitive_execute(net_fwd[i], stream,
net_fwd_args[i].nargs, net_fwd_args[i].args));
/* Update net_diff_dst */
void *net_output = NULL; // output from forward stream:
CHECK(mkldnn_memory_get_data_handle(pool_user_dst_memory, &net_output));
/*...user updates net_diff_dst using net_output...*/
// some user defined func update_diff_dst(net_diff_dst, net_output)
/* Backward pass */
for (uint32_t i = 0; i < n_bwd; ++i)
CHECK(mkldnn_primitive_execute(net_bwd[i], stream,
net_bwd_args[i].nargs, net_bwd_args[i].args));
/*... update weights ... */
CHECK(mkldnn_memory_get_data_handle(
conv_user_diff_weights_memory, &net_diff_weights));
CHECK(mkldnn_memory_get_data_handle(
conv_diff_bias_memory, &net_diff_bias));
/* ...user updates weights and bias using diff weights and bias...*/
// some user defined func update_weights(conv_user_weights_memory,
// conv_bias_memory,
// net_diff_weights, net_diff_bias);
}
CHECK(mkldnn_stream_wait(stream));
mkldnn_stream_destroy(stream);
/* clean up nets */
for (uint32_t i = 0; i < n_fwd; ++i)
free_arg_node(&net_fwd_args[i]);
for (uint32_t i = 0; i < n_bwd; ++i)
free_arg_node(&net_bwd_args[i]);
/* Cleanup forward */
CHECK(mkldnn_primitive_desc_destroy(pool_pd));
CHECK(mkldnn_primitive_desc_destroy(lrn_pd));
CHECK(mkldnn_primitive_desc_destroy(relu_pd));
CHECK(mkldnn_primitive_desc_destroy(conv_pd));
free(net_src);
free(net_dst);
mkldnn_memory_destroy(conv_user_src_memory);
mkldnn_memory_destroy(conv_user_weights_memory);
mkldnn_memory_destroy(conv_user_bias_memory);
mkldnn_memory_destroy(conv_internal_src_memory);
mkldnn_memory_destroy(conv_internal_weights_memory);
mkldnn_memory_destroy(conv_internal_dst_memory);
mkldnn_primitive_destroy(conv_reorder_src);
mkldnn_primitive_destroy(conv_reorder_weights);
mkldnn_primitive_destroy(conv);
free(conv_weights);
free(conv_bias);
mkldnn_memory_destroy(relu_dst_memory);
mkldnn_primitive_destroy(relu);
mkldnn_memory_destroy(lrn_ws_memory);
mkldnn_memory_destroy(lrn_dst_memory);
mkldnn_primitive_destroy(lrn);
mkldnn_memory_destroy(pool_user_dst_memory);
mkldnn_memory_destroy(pool_internal_dst_memory);
mkldnn_memory_destroy(pool_ws_memory);
mkldnn_primitive_destroy(pool_reorder_dst);
mkldnn_primitive_destroy(pool);
/* Cleanup backward */
CHECK(mkldnn_primitive_desc_destroy(pool_bwd_pd));
CHECK(mkldnn_primitive_desc_destroy(lrn_bwd_pd));
CHECK(mkldnn_primitive_desc_destroy(relu_bwd_pd));
CHECK(mkldnn_primitive_desc_destroy(conv_bwd_weights_pd));
mkldnn_memory_destroy(pool_user_diff_dst_memory);
mkldnn_memory_destroy(pool_diff_src_memory);
mkldnn_memory_destroy(pool_internal_diff_dst_memory);
mkldnn_primitive_destroy(pool_reorder_diff_dst);
mkldnn_primitive_destroy(pool_bwd);
free(net_diff_dst);
mkldnn_memory_destroy(lrn_diff_src_memory);
mkldnn_primitive_destroy(lrn_bwd);
mkldnn_memory_destroy(relu_diff_src_memory);
mkldnn_primitive_destroy(relu_bwd);
mkldnn_memory_destroy(conv_user_diff_weights_memory);
mkldnn_memory_destroy(conv_diff_bias_memory);
mkldnn_memory_destroy(conv_bwd_internal_src_memory);
mkldnn_primitive_destroy(conv_bwd_reorder_src);
mkldnn_memory_destroy(conv_internal_diff_dst_memory);
mkldnn_primitive_destroy(conv_reorder_diff_dst);
mkldnn_memory_destroy(conv_internal_diff_weights_memory);
mkldnn_primitive_destroy(conv_reorder_diff_weights);
mkldnn_primitive_destroy(conv_bwd_weights);
free(conv_diff_bias_buffer);
free(conv_user_diff_weights_buffer);
mkldnn_engine_destroy(engine);
return mkldnn_success;
}
Sec::Sec(const RCP<const Basic> &arg)
{
CSYMPY_ASSERT(is_canonical(arg))
set_arg(arg);
}
void set_arg(size_t index, const T &value)
{
set_arg(index, sizeof(value), &value);
}
void
parse_commandline (int argc, char **argv)
{
char next_arg, i, arg_error = 0;
Log ("--[ PARSING COMMAND LINE ]--------------------------\n");
#if 0 // !defined(WIN32) && !defined(SOLARIS) && !defined(NGC) && !defined(PSP)
argp_parse (&argp, argc, argv, 0, 0, &option);
#else
next_arg = 0;
for (i = 1; i < argc; i++)
if (!next_arg)
{
if (argv[i][0] == '-')
{
if (strlen (argv[i]) == 2)
{
switch (argv[i][1])
{
default:
next_arg = argv[i][1];
break;
}
}
else
arg_error |= set_arg (argv[i][1], (char *) &argv[i][2]);
}
else
{
if (!cart_name[0])
{
strcpy (cart_name, argv[i]);
Log ("Setting card name to %s\n", cart_name);
{
int x;
for (x = 0; x < strlen (cart_name); x++)
if (cart_name[x] == '\\')
cart_name[x] = '/';
}
}
else if (!bmdefault)
{
Log ("Setting backup mem file name to %s\n", argv[i]);
bmdefault = argv[i];
}
else
{
Log ("Unrecognized option : %s\n", argv[i]);
arg_error = 1;
};
}
}
else
{
arg_error |= set_arg (next_arg, argv[i]);
next_arg = 0;
}
if (next_arg)
{
Log ("No value for last arg : %c\n", next_arg);
next_arg = 0;
arg_error = 1;
};
#endif
Log ("End of parsing command line\n");
video_driver = 0;
if (use_eagle)
video_driver = 1;
else if (use_scanline)
video_driver = 2;
}
/// \internal_
///
/// specialization for buffer, image2d and image3d
void set_arg(size_t index, const memory_object &mem)
{
BOOST_ASSERT(mem.get_context() == this->get_context());
set_arg(index, sizeof(cl_mem), static_cast<const void *>(&mem.get()));
}
int main( int argc, char **argv )
{
//MPI Initialize
if( MPI_Init(&argc,&argv) != MPI_SUCCESS )
{
std::cerr << "MPI_Init error." << std::endl;
return false;
}
Staging STG;
//引数の取り出し＆セット
set_arg(STG,argc,argv);
CIO::E_CIO_ERRORCODE ret;
vector<int> readRankList; ///< 読込みランクリスト
//読込みDFIファイルのループ
for( int i=0; i<STG.m_dfi_fname.size(); i++ ) {
printf("---- i=%d m_dfi_fname=%s\n",i,STG.m_dfi_fname[i].c_str() );
fflush(stdout);
//初期化、ファイルの読込み、DFIのインスタンス
if( !STG.Initial(STG.m_infofile, STG.m_dfi_fname[i]) ) {
printf("ERROR Initial()\n");
return 0;
}
//DFIのdirectory path get
STG.m_inPath = CIO::cioPath_DirName(STG.m_dfi_fname[i]);
//printf(" STG.m_inPath = %s\n",STG.m_inPath.c_str() );
bool isSameDiv = true; ///< 分割数フラグ true:1x1 false:MxN
bool isSame = true; ///< 粗密フラグ true:密 false:粗
CIO::E_CIO_READTYPE readflag; ///< 読込み判定フラグ
// 分割数フラグの設定
for(int j=0; j<3; j++ ) {
if( STG.m_Gdiv[j] != STG.dfi_Domain->GlobalDivision[j] )
{
isSameDiv = false;
}
}
// 粗密フラグの設定
if( STG.CheckGlobalVoxel(STG.m_GVoxel,(int *)STG.dfi_Domain->GlobalVoxel) == STG_E_GV_SAME )
{
isSame = true;
}
else if( STG.CheckGlobalVoxel(STG.m_GVoxel,(int *)STG.dfi_Domain->GlobalVoxel) == STG_E_GVX2_SAME )
{
isSame = false;
} else {
printf("ERROR Dimension size : %d %d %d\n",STG.m_GVoxel[0],STG.m_GVoxel[1],STG.m_GVoxel[2]);
return 0;
}
//読込み判定フラグの設定
if( isSameDiv == true )
{
if( isSame == true )
{
readflag = CIO::E_CIO_SAMEDIV_SAMERES;
}
else
{
readflag = CIO::E_CIO_SAMEDIV_REFINEMENT;
}
}
else
{
if( isSame == true )
{
readflag = CIO::E_CIO_DIFFDIV_SAMERES;
}
else
{
readflag = CIO::E_CIO_DIFFDIV_REFINEMENT;
}
}
int numRank = STG.m_GRankInfo.size();
//ランクマップの生成
int* rankMap = STG.CreateRankMap();
//STG.m_GRankInfoの生成
STG.m_HeadTail=NULL;
if( numRank>0 ) {
if( numRank != STG.m_NumberOfRank ) {
printf("ERROR MISMATCH NumberOfRank\n");
return 0;
}
STG.m_HeadTail = new int[numRank][6];
//ランク毎のXYZ方向のheadとtaileテーブルの生成
if( !STG.CreateHeadTail(rankMap,STG.m_GRankInfo) ) {
printf("ERROR CreateHeadTail()\n");
return 0;
}
} else {
size_t ndiv = STG.m_Gdiv[0]*STG.m_Gdiv[1]*STG.m_Gdiv[2];
STG.m_HeadTail = new int[ndiv][6];
//ランク毎のXYZ方向のheadとtaileテーブルの生成
if( !STG.CreateHeadTail(rankMap) ) {
printf("ERROR CreateHeadTail()\n");
return 0;
}
}
//並列数のセット
numRank=STG.m_GRankInfo.size();
//並列数のループ
char tmp[20];
if( STG.m_outPath == "" ) STG.m_outPath=".";
int len = STG.m_outPath.size()+7;
//printf("---- i=%d numRank=%d\n",i,numRank );
//fflush(stdout);
for(int j=0; j<numRank; j++) {
//printf(" ---- i=%d j=%d\n",i,j );
//fflush(stdout);
//読込みランクリストの生成
readRankList.clear();
cio_Domain domain;
for(int k=0; k<3; k++ ) {
domain.GlobalOrigin[k] = STG.dfi_Domain->GlobalOrigin[k];
domain.GlobalRegion[k] = STG.dfi_Domain->GlobalRegion[k];
domain.GlobalVoxel[k] = STG.dfi_Domain->GlobalVoxel[k];
domain.GlobalDivision[k] = STG.dfi_Domain->GlobalDivision[k];
}
domain.ActiveSubdomainFile = STG.dfi_Domain->ActiveSubdomainFile;
ret=STG.dfi_Process->CheckReadRank(domain,
(const int *)STG.m_GRankInfo[j].HeadIndex,
(const int *)STG.m_GRankInfo[j].TailIndex,readflag,readRankList);
if( ret != CIO::E_CIO_SUCCESS ) return 0;
//ファイルのコピー
//printf(" ---- i=%d j=%d STG.FileCopy(() Start\n",i,j );
//fflush(stdout);
STG.FileCopy(readRankList,STG.m_GRankInfo[j].RankID);
//printf(" ---- i=%d j=%d STG.FileCopy(() End\n",i,j );
//fflush(stdout);
}
//dfiファイル出力
//printf(" ---- i=%d STG.OutputDFI(() Start\n",i );
//fflush(stdout);
if( !STG.OutputDFI(STG.m_dfi_fname[i], rankMap) ) {
printf("EEROR OutputDFI()\n");
return 0;
}
//printf(" ---- i=%d STG.OutputDFI(() End\n",i );
//fflush(stdout);
}
printf("####### normal end ######\n");
return 1;
}
/// \internal_
///
/// specialization for image samplers
void set_arg(size_t index, const image_sampler &sampler)
{
cl_sampler sampler_ = cl_sampler(sampler);
set_arg(index, sizeof(cl_sampler), static_cast<const void *>(&sampler_));
}
static void set_int_arg(int val, int pos)
{
set_arg(PyInt_FromLong((long)val), pos);
}
