void Canonicalizer::do_ArrayLength (ArrayLength* x) { NewArray* na; Constant* ct; LoadField* lf; if ((na = x->array()->as_NewArray()) != NULL) { // New arrays might have the known length. // Do not use the Constant itself, but create a new Constant // with same value Otherwise a Constant is live over multiple // blocks without being registered in a state array. Constant* length; if (na->length() != NULL && (length = na->length()->as_Constant()) != NULL) { assert(length->type()->as_IntConstant() != NULL, "array length must be integer"); set_constant(length->type()->as_IntConstant()->value()); } } else if ((ct = x->array()->as_Constant()) != NULL) { // Constant arrays have constant lengths. ArrayConstant* cnst = ct->type()->as_ArrayConstant(); if (cnst != NULL) { set_constant(cnst->value()->length()); } } else if ((lf = x->array()->as_LoadField()) != NULL) { ciField* field = lf->field(); if (field->is_static_constant()) { assert(PatchALot || ScavengeRootsInCode < 2, "Constant field loads are folded during parsing"); ciObject* c = field->constant_value().as_object(); if (!c->is_null_object()) { set_constant(c->as_array()->length()); } } } }
void Canonicalizer::do_ShiftOp (ShiftOp* x) { ValueType* t = x->x()->type(); ValueType* t2 = x->y()->type(); if (t->is_constant()) { switch (t->tag()) { case intTag : if (t->as_IntConstant()->value() == 0) { set_constant(0); return; } break; case longTag : if (t->as_LongConstant()->value() == (jlong)0) { set_constant(jlong_cast(0)); return; } break; default : ShouldNotReachHere(); } if (t2->is_constant()) { if (t->tag() == intTag) { int value = t->as_IntConstant()->value(); int shift = t2->as_IntConstant()->value() & 31; jint mask = ~(~0 << (32 - shift)); if (shift == 0) mask = ~0; switch (x->op()) { case Bytecodes::_ishl: set_constant(value << shift); return; case Bytecodes::_ishr: set_constant(value >> shift); return; case Bytecodes::_iushr: set_constant((value >> shift) & mask); return; } } else if (t->tag() == longTag) { jlong value = t->as_LongConstant()->value(); int shift = t2->as_IntConstant()->value() & 63; jlong mask = ~(~jlong_cast(0) << (64 - shift)); if (shift == 0) mask = ~jlong_cast(0); switch (x->op()) { case Bytecodes::_lshl: set_constant(value << shift); return; case Bytecodes::_lshr: set_constant(value >> shift); return; case Bytecodes::_lushr: set_constant((value >> shift) & mask); return; } }
void Canonicalizer::do_ArrayLength (ArrayLength* x) { NewArray* array = x->array()->as_NewArray(); if (array != NULL && array->length() != NULL) { Constant* length = array->length()->as_Constant(); if (length != NULL) { // do not use the Constant itself, but create a new Constant // with same value Otherwise a Constant is live over multiple // blocks without being registered in a state array. assert(length->type()->as_IntConstant() != NULL, "array length must be integer"); set_constant(length->type()->as_IntConstant()->value()); } } else { LoadField* lf = x->array()->as_LoadField(); if (lf != NULL) { ciField* field = lf->field(); if (field->is_constant() && field->is_static()) { // final static field ciObject* c = field->constant_value().as_object(); if (c->is_array()) { ciArray* array = (ciArray*) c; set_constant(array->length()); } } } } }
void Canonicalizer::do_NegateOp(NegateOp* x) { ValueType* t = x->x()->type(); if (t->is_constant()) { switch (t->tag()) { case intTag : set_constant(-t->as_IntConstant ()->value()); return; case longTag : set_constant(-t->as_LongConstant ()->value()); return; case floatTag : set_constant(-t->as_FloatConstant ()->value()); return; case doubleTag: set_constant(-t->as_DoubleConstant()->value()); return; default : ShouldNotReachHere(); } } }
bool Theme::_set(const StringName& p_name, const Variant& p_value) { String sname=p_name; if (sname.find("/")!=-1) { String type=sname.get_slicec('/',1); String node_type=sname.get_slicec('/',0); String name=sname.get_slicec('/',2); if (type=="icons") { set_icon(name,node_type,p_value); } else if (type=="styles") { set_stylebox(name,node_type,p_value); } else if (type=="fonts") { set_font(name,node_type,p_value); } else if (type=="colors") { set_color(name,node_type,p_value); } else if (type=="constants") { set_constant(name,node_type,p_value); } else return false; return true; } return false; }
TEST(BasicSial,DISABLED_exit_statement_test) { std::string job("exit_statement_test"); sip::DataManager::scope_count=0; double x = 3.456; double y = -0.1; int norb = 3; { init_setup(job.c_str()); set_scalar("x",x); set_scalar("y",y); set_constant("norb",norb); std::string tmp = job + ".siox"; const char* nm= tmp.c_str(); add_sial_program(nm); int segs[] = {2,3,4,2,3,4,2,3,4,2,3,4,2,3,4}; set_aoindex_info(15,segs); finalize_setup(); } std::stringstream output; TestControllerParallel controller(job, true, VERBOSE_TEST, "", output); controller.initSipTables(); controller.run(); if(attr->is_worker()) { EXPECT_DOUBLE_EQ(12, controller.int_value("counter_j")); EXPECT_DOUBLE_EQ(4, controller.int_value("counter_i")); EXPECT_EQ(0, sip::DataManager::scope_count); EXPECT_TRUE(controller.worker_->all_stacks_empty()); EXPECT_EQ(0, controller.worker_->num_blocks_in_blockmap()); } }
void Canonicalizer::do_ShiftOp (ShiftOp* x) { ValueType* t = x->x()->type(); if (t->is_constant()) { switch (t->tag()) { case intTag : if (t->as_IntConstant()->value() == 0) set_constant(0); return; case longTag : if (t->as_LongConstant()->value() == (jlong)0) set_constant(jlong_cast(0)); return; default : ShouldNotReachHere(); } } ValueType* t2 = x->y()->type(); if (t2->is_constant()) { switch (t2->tag()) { case intTag : if (t2->as_IntConstant()->value() == 0) set_canonical(x->x()); return; default : ShouldNotReachHere(); } } }
void basic_pardo_test(int max_dims, int lower[], int upper[], bool expect_success = true) { assert(max_dims <= 6); for (int num_dims = 1; num_dims <= 6; ++num_dims) { std::stringstream job_ss; job_ss << "pardo_loop_" << num_dims << "d"; std::string job = job_ss.str(); //total number of iters for this sial program int num_iters = 1; for (int j = 0; j < num_dims; ++j) { num_iters *= ((upper[j] - lower[j]) + 1); } //create .dat file if (attr->global_rank() == 0) { init_setup(job.c_str()); //add values for upper and lower bounds for (int i = 0; i < num_dims; ++i) { std::stringstream lower_ss, upper_ss; lower_ss << "lower" << i; upper_ss << "upper" << i; set_constant(lower_ss.str().c_str(), lower[i]); set_constant(upper_ss.str().c_str(), upper[i]); } std::string tmp = job + ".siox"; const char* nm = tmp.c_str(); add_sial_program(nm); finalize_setup(); } TestControllerParallel controller(job, true, VERBOSE_TEST, "This is a test of " + job, std::cout, expect_success); controller.initSipTables(); controller.run(); if (attr->global_rank() == 0) { double total = controller.worker_->scalar_value("total"); if (VERBOSE_TEST) { std::cout << "num_iters=" << num_iters << ", total=" << total << std::endl; } EXPECT_EQ(num_iters, int(total)); } } }
TEST(Sial,put_test) { barrier(); std::string job("put_test"); int norb = 3; int segs[] = {2,3,2}; if (attr->global_rank() == 0) { init_setup(job.c_str()); set_constant("norb", norb); set_constant("norb_squared", norb*norb); std::string tmp = job + ".siox"; const char* nm = tmp.c_str(); add_sial_program(nm); set_aoindex_info(3, segs); finalize_setup(); } barrier(); std::stringstream output; TestControllerParallel controller(job, true, VERBOSE_TEST, " ", output); controller.initSipTables(); if (attr->is_worker()) { std::cout << "creating and starting a worker" << std::endl << std::flush; controller.runWorker(); EXPECT_TRUE(controller.worker_->all_stacks_empty()); std::vector<int> index_vec; for (int i = 0; i < norb; ++i) { for (int j = 0; j < norb; ++j) { int k = (i*norb + j)+1; index_vec.push_back(k); double * local_block = controller.local_block("result",index_vec); double value = local_block[0]; double expected = k*k*segs[i]*segs[j]; std::cout << "k,value= " << k << " " << value << std::endl; ASSERT_DOUBLE_EQ(expected, value); index_vec.clear(); } } } else { std::cout << "creating and starting a server" << std::endl << std::flush; controller.runServer(); } }
TEST(Sial,persistent_distributed_array_mpi){ std::string job("persistent_distributed_array_mpi"); double x = 3.456; int norb = 2; int segs[] = {2,3}; if (attr->global_rank() == 0){ init_setup(job.c_str()); set_scalar("x",x); set_constant("norb",norb); std::string tmp = job + "1.siox"; const char* nm= tmp.c_str(); add_sial_program(nm); std::string tmp1 = job + "2.siox"; const char* nm1= tmp1.c_str(); add_sial_program(nm1); set_aoindex_info(2,segs); finalize_setup(); } std::stringstream output; TestControllerParallel controller(job, true, true, "", output); //run first program controller.initSipTables(); controller.run(); controller.print_timers(std::cout); std::cout << "Rank " << attr->global_rank() << " in persistent_distributed_array_mpi starting second program" << std::endl << std::flush; //run second program controller.initSipTables(); controller.run(); if (attr->is_worker()) { int i,j; for (i=1; i <= norb ; ++i ){ for (j = 1; j <= norb; ++j){ double firstval = (i-1)*norb + j; std::vector<int> indices; indices.push_back(i); indices.push_back(j); double * block_data = controller.local_block(std::string("a"),indices); size_t block_size = segs[i-1] * segs[j-1]; for (size_t count = 0; count < block_size; ++count){ ASSERT_DOUBLE_EQ(3*firstval, block_data[count]); firstval++; } } } } controller.print_timers(std::cout); }
void Canonicalizer::do_Intrinsic (Intrinsic* x) { switch (x->id()) { case ciMethod::_floatToRawIntBits : { FloatConstant* c = x->argument_at(0)->type()->as_FloatConstant(); if (c != NULL) { JavaValue v; v.set_jfloat(c->value()); set_constant(v.get_jint()); } break; } case ciMethod::_intBitsToFloat : { IntConstant* c = x->argument_at(0)->type()->as_IntConstant(); if (c != NULL) { JavaValue v; v.set_jint(c->value()); set_constant(v.get_jfloat()); } break; } case ciMethod::_doubleToRawLongBits : { DoubleConstant* c = x->argument_at(0)->type()->as_DoubleConstant(); if (c != NULL) { JavaValue v; v.set_jdouble(c->value()); set_constant(v.get_jlong()); } break; } case ciMethod::_longBitsToDouble : { LongConstant* c = x->argument_at(0)->type()->as_LongConstant(); if (c != NULL) { JavaValue v; v.set_jlong(c->value()); set_constant(v.get_jdouble()); } break; } } }
void Image_controls::on_scalar_constant_spin_box__valueChanged(double arg1) { set_constant(static_cast<float>(arg1)); if (0 == ui->image_source_combo_box_->currentIndex()) { update_constant(); } else { ui->image_source_combo_box_->setCurrentIndex(0); } }
TEST(Sial,broadcast_static){ std::string job("broadcast_static"); int norb = 3; int segs[] = {2,3,2}; int root = 0; if (attr->global_rank() == 0) { init_setup(job.c_str()); set_constant("norb", norb); set_constant("root", root); std::string tmp = job + ".siox"; const char* nm = tmp.c_str(); add_sial_program(nm); set_aoindex_info(3, segs); finalize_setup(); } std::stringstream output; TestControllerParallel controller(job, true, VERBOSE_TEST, "", output); controller.initSipTables(); controller.run(); if (attr->is_worker()) { double * a = controller.static_array("a"); int expected[] = {1, 2, 1, 2, 3, 1, 2, 3, 4, 4, 5, 6, 3, 4, 1, 2, 1, 2, 3, 1, 2, 3, 4, 4, 5, 6, 3, 4, 5, 6, 7, 8, 9, 5, 6, 1, 2, 1, 2, 3, 1, 2, 3, 4, 4, 5, 6, 3, 4}; int side = 2+3+2; //size of one side, from seg sizes in segs array above int size = side*side; int i = 0; for (i; i < size; ++i){ ASSERT_DOUBLE_EQ(expected[i], a[i]); } } }
TEST(Sial,get_mpi){ std::string job("get_mpi"); //create setup_file double x = 3.456; int norb = 4; int segs[] = {2,3,4,1}; if (attr->global_rank() == 0){ init_setup(job.c_str()); set_scalar("x",x); set_constant("norb",norb); std::string tmp = job + ".siox"; const char* nm= tmp.c_str(); add_sial_program(nm); set_aoindex_info(4,segs); finalize_setup(); } std::stringstream output; TestControllerParallel controller(job, true, VERBOSE_TEST, "", output); controller.initSipTables(); controller.run(); if(attr->global_rank()==0){ // Test a(1,1) // Get the data for local array block "b" int a_slot = controller.worker_->array_slot(std::string("a")); sip::index_selector_t a_indices_1; a_indices_1[0] = 1; a_indices_1[1] = 1; for (int i = 2; i < MAX_RANK; i++) a_indices_1[i] = sip::unused_index_value; sip::BlockId a_bid_1(a_slot, a_indices_1); std::cout << a_bid_1 << std::endl; sip::Block::BlockPtr a_bptr_1 = controller.worker_->get_block_for_reading(a_bid_1); sip::Block::dataPtr a_data_1 = a_bptr_1->get_data(); std::cout << " Comparing block " << a_bid_1 << std::endl; for (int i=0; i<segs[0]; i++){ for (int j=0; j<segs[0]; j++){ ASSERT_DOUBLE_EQ(42*3, a_data_1[i*segs[0] + j]); } } } }
/* TODO check what this test does. */ TEST(Sip,message_number_wraparound){ std::string job("message_number_wraparound_test"); if (attr->global_rank() == 0){ init_setup(job.c_str()); set_constant("norb",1); std::string tmp = job + ".siox"; const char* nm= tmp.c_str(); add_sial_program(nm); int segs[] = {1}; set_aoindex_info(1,segs); finalize_setup(); } std::stringstream output; TestControllerParallel controller(job, true, VERBOSE_TEST, "", output); controller.initSipTables(); controller.run(); }
TEST(Sial,put_accumulate_mpi){ std::string job("put_accumulate_mpi"); double x = 3.456; int norb = 4; if (attr->global_rank() == 0){ init_setup(job.c_str()); set_scalar("x",x); set_constant("norb",norb); std::string tmp = job + ".siox"; const char* nm= tmp.c_str(); add_sial_program(nm); int segs[] = {2,3,4,1}; set_aoindex_info(4,segs); finalize_setup(); } std::stringstream output; TestControllerParallel controller(job, true, VERBOSE_TEST, "", output); controller.initSipTables(); controller.run(); }
TEST(Sial,all_rank_print){ std::string job("all_rank_print_test"); std::cout << "JOBNAME = " << job << std::endl; double x = 3.456; int norb = 2; if (attr->global_rank() == 0){ init_setup(job.c_str()); set_scalar("x",x); set_constant("norb",norb); std::string tmp = job + ".siox"; const char* nm= tmp.c_str(); add_sial_program(nm); int segs[] = {2,3}; set_aoindex_info(2,segs); finalize_setup(); } std::stringstream output; TestControllerParallel controller(job, true, VERBOSE_TEST, "", output); controller.initSipTables(); controller.run(); }
void Image_controls::on_color_constant_button__clicked() { rendering::Color3 rgb = rendering::linear_to_sRGB(constant_); QColor qcolor = QColorDialog::getColor(QColor::fromRgbF(rgb.r, rgb.g, rgb.b), this, "Color constant"); if (qcolor.isValid()) { rgb = rendering::Color3(qcolor.redF(), qcolor.greenF(), qcolor.blueF()); set_constant(rendering::sRGB_to_linear(rgb)); if (0 == ui->image_source_combo_box_->currentIndex()) { update_constant(); } else { ui->image_source_combo_box_->setCurrentIndex(0); } } }
void Canonicalizer::do_Op2(Op2* x) { if (x->x() == x->y()) { switch (x->op()) { case Bytecodes::_isub: set_constant(0); return; case Bytecodes::_lsub: set_constant(jlong_cast(0)); return; case Bytecodes::_iand: // fall through case Bytecodes::_land: // fall through case Bytecodes::_ior: // fall through case Bytecodes::_lor : set_canonical(x->x()); return; case Bytecodes::_ixor: set_constant(0); return; case Bytecodes::_lxor: set_constant(jlong_cast(0)); return; } } if (x->x()->type()->is_constant() && x->y()->type()->is_constant()) { // do constant folding for selected operations switch (x->type()->tag()) { case intTag: { jint a = x->x()->type()->as_IntConstant()->value(); jint b = x->y()->type()->as_IntConstant()->value(); switch (x->op()) { case Bytecodes::_iadd: set_constant(a + b); return; case Bytecodes::_isub: set_constant(a - b); return; case Bytecodes::_imul: set_constant(a * b); return; case Bytecodes::_idiv: if (b != 0) { if (a == min_jint && b == -1) { set_constant(min_jint); } else { set_constant(a / b); } return; } break; case Bytecodes::_irem: if (b != 0) { if (a == min_jint && b == -1) { set_constant(0); } else { set_constant(a % b); } return; } break; case Bytecodes::_iand: set_constant(a & b); return; case Bytecodes::_ior : set_constant(a | b); return; case Bytecodes::_ixor: set_constant(a ^ b); return; } } break; case longTag: { jlong a = x->x()->type()->as_LongConstant()->value(); jlong b = x->y()->type()->as_LongConstant()->value(); switch (x->op()) { case Bytecodes::_ladd: set_constant(a + b); return; case Bytecodes::_lsub: set_constant(a - b); return; case Bytecodes::_lmul: set_constant(a * b); return; case Bytecodes::_ldiv: if (b != 0) { set_constant(SharedRuntime::ldiv(b, a)); return; } break; case Bytecodes::_lrem: if (b != 0) { set_constant(SharedRuntime::lrem(b, a)); return; } break; case Bytecodes::_land: set_constant(a & b); return; case Bytecodes::_lor : set_constant(a | b); return; case Bytecodes::_lxor: set_constant(a ^ b); return; } } break; // other cases not implemented (must be extremely careful with floats & doubles!) } } // make sure constant is on the right side, if any move_const_to_right(x); if (x->y()->type()->is_constant()) { // do constant folding for selected operations switch (x->type()->tag()) { case intTag: if (x->y()->type()->as_IntConstant()->value() == 0) { switch (x->op()) { case Bytecodes::_iadd: set_canonical(x->x()); return; case Bytecodes::_isub: set_canonical(x->x()); return; case Bytecodes::_imul: set_constant(0); return; // Note: for div and rem, make sure that C semantics // corresponds to Java semantics! case Bytecodes::_iand: set_constant(0); return; case Bytecodes::_ior : set_canonical(x->x()); return; } } break; case longTag: if (x->y()->type()->as_LongConstant()->value() == (jlong)0) { switch (x->op()) { case Bytecodes::_ladd: set_canonical(x->x()); return; case Bytecodes::_lsub: set_canonical(x->x()); return; case Bytecodes::_lmul: set_constant((jlong)0); return; // Note: for div and rem, make sure that C semantics // corresponds to Java semantics! case Bytecodes::_land: set_constant((jlong)0); return; case Bytecodes::_lor : set_canonical(x->x()); return; } } break; } } }
TEST(SimpleMPI,persistent_distributed_array_mpi) { sip::GlobalState::reset_program_count(); sip::SIPMPIAttr &sip_mpi_attr = sip::SIPMPIAttr::get_instance(); int my_rank = sip_mpi_attr.global_rank(); std::cout << "****************************************\n"; sip::DataManager::scope_count=0; //create setup_file std::string job("persistent_distributed_array_mpi"); std::cout << "JOBNAME = " << job << std::endl; double x = 3.456; int norb = 2; int segs[] = {2,3}; if (attr.global_rank() == 0) { init_setup(job.c_str()); set_scalar("x",x); set_constant("norb",norb); std::string tmp = job + "1.siox"; const char* nm= tmp.c_str(); add_sial_program(nm); std::string tmp1 = job + "2.siox"; const char* nm1= tmp1.c_str(); add_sial_program(nm1); set_aoindex_info(2,segs); finalize_setup(); } sip::SIPMPIUtils::check_err(MPI_Barrier(MPI_COMM_WORLD)); setup::BinaryInputFile setup_file(job + ".dat"); setup::SetupReader setup_reader(setup_file); std::cout << "SETUP READER DATA:\n" << setup_reader<< std::endl; //get siox name from setup, load and print the sip tables std::string prog_name = setup_reader.sial_prog_list_.at(0); std::string siox_dir(dir_name); setup::BinaryInputFile siox_file(siox_dir + prog_name); sip::SipTables sipTables(setup_reader, siox_file); if (!sip_mpi_attr.is_server()) { std::cout << "SIP TABLES" << '\n' << sipTables << std::endl; } if (sip_mpi_attr.global_rank()==0) { std::cout << "\n\n\n\n>>>>>>>>>>>>starting SIAL PROGRAM "<< job << std::endl; } //create worker and server sip::DataDistribution data_distribution(sipTables, sip_mpi_attr); sip::GlobalState::set_program_name(prog_name); sip::GlobalState::increment_program(); sip::WorkerPersistentArrayManager wpam; sip::ServerPersistentArrayManager spam; std::cout << "rank " << my_rank << " reached first barrier" << std::endl << std::flush; MPI_Barrier(MPI_COMM_WORLD); std::cout << "rank " << my_rank << " passed first barrier" << std::endl << std::flush; if (sip_mpi_attr.is_server()) { sip::SIPServer server(sipTables, data_distribution, sip_mpi_attr, &spam); std::cout << "at first barrier in prog 1 at server" << std::endl << std::flush; MPI_Barrier(MPI_COMM_WORLD); std::cout<<"passed first barrier at server, starting server" << std::endl; server.run(); spam.save_marked_arrays(&server); std::cout << "Server state after termination" << server << std::endl; } else { sip::SialxTimer sialxTimer(sipTables.max_timer_slots()); sip::Interpreter runner(sipTables, sialxTimer, &wpam); std::cout << "at first barrier in prog 1 at worker" << std::endl << std::flush; MPI_Barrier(MPI_COMM_WORLD); std::cout << "after first barrier; starting worker for "<< job << std::endl; runner.interpret(); wpam.save_marked_arrays(&runner); std::cout << "\n end of prog1 at worker"<< std::endl; } std::cout << std::flush; if (sip_mpi_attr.global_rank()==0) { std::cout << "@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@" << std::endl << std::flush; std::cout << "SETUP READER DATA FOR SECOND PROGRAM:\n" << setup_reader<< std::endl; } std::string prog_name2 = setup_reader.sial_prog_list_.at(1); setup::BinaryInputFile siox_file2(siox_dir + prog_name2); sip::SipTables sipTables2(setup_reader, siox_file2); if (sip_mpi_attr.global_rank()==0) { std::cout << "SIP TABLES FOR " << prog_name2 << '\n' << sipTables2 << std::endl; } sip::DataDistribution data_distribution2(sipTables2, sip_mpi_attr); sip::GlobalState::set_program_name(prog_name); sip::GlobalState::increment_program(); std::cout << "rank " << my_rank << " reached second barrier in test" << std::endl << std::flush; MPI_Barrier(MPI_COMM_WORLD); std::cout << "rank " << my_rank << " passed second barrier in test" << std::endl << std::flush; if (sip_mpi_attr.is_server()) { sip::SIPServer server(sipTables2, data_distribution2, sip_mpi_attr, &spam); std::cout << "barrier in prog 2 at server" << std::endl << std::flush; MPI_Barrier(MPI_COMM_WORLD); std::cout<< "rank " << my_rank << "starting server for prog 2" << std::endl; server.run(); std::cout<< "rank " << my_rank << "Server state after termination of prog2" << server << std::endl; } else { sip::SialxTimer sialxTimer2(sipTables2.max_timer_slots()); sip::Interpreter runner(sipTables2, sialxTimer2, &wpam); std::cout << "rank " << my_rank << "barrier in prog 2 at worker" << std::endl << std::flush; MPI_Barrier(MPI_COMM_WORLD); std::cout << "rank " << my_rank << "starting worker for prog2"<< job << std::endl; runner.interpret(); std::cout << "\nSIAL PROGRAM 2 TERMINATED"<< std::endl; // Test contents of blocks of distributed array "b" // Get the data for local array block "b" int b_slot = runner.array_slot(std::string("lb")); // Test b(1,1) sip::index_selector_t b_indices_1; b_indices_1[0] = 1; b_indices_1[1] = 1; for (int i = 2; i < MAX_RANK; i++) b_indices_1[i] = sip::unused_index_value; sip::BlockId b_bid_1(b_slot, b_indices_1); std::cout << b_bid_1 << std::endl; sip::Block::BlockPtr b_bptr_1 = runner.get_block_for_reading(b_bid_1); sip::Block::dataPtr b_data_1 = b_bptr_1->get_data(); std::cout << " Comparing block " << b_bid_1 << std::endl; double fill_seq_1_1 = 1.0; for (int i=0; i<segs[0]; i++) { for (int j=0; j<segs[0]; j++) { ASSERT_DOUBLE_EQ(fill_seq_1_1, b_data_1[i*segs[0] + j]); fill_seq_1_1++; } } // Test b(2, 2) sip::index_selector_t b_indices_2; b_indices_2[0] = 2; b_indices_2[1] = 2; for (int i = 2; i < MAX_RANK; i++) b_indices_2[i] = sip::unused_index_value; sip::BlockId b_bid_2(b_slot, b_indices_2); std::cout << b_bid_2 << std::endl; sip::Block::BlockPtr b_bptr_2 = runner.get_block_for_reading(b_bid_2); sip::Block::dataPtr b_data_2 = b_bptr_2->get_data(); std::cout << " Comparing block " << b_bid_2 << std::endl; double fill_seq_2_2 = 4.0; for (int i=0; i<segs[1]; i++) { for (int j=0; j<segs[1]; j++) { ASSERT_DOUBLE_EQ(fill_seq_2_2, b_data_2[i*segs[1] + j]); fill_seq_2_2++; } } // Test b(2,1) sip::index_selector_t b_indices_3; b_indices_3[0] = 2; b_indices_3[1] = 1; for (int i = 2; i < MAX_RANK; i++) b_indices_3[i] = sip::unused_index_value; sip::BlockId b_bid_3(b_slot, b_indices_3); std::cout << b_bid_3 << std::endl; sip::Block::BlockPtr b_bptr_3 = runner.get_block_for_reading(b_bid_3); sip::Block::dataPtr b_data_3 = b_bptr_3->get_data(); std::cout << " Comparing block " << b_bid_3 << std::endl; double fill_seq_2_1 = 3.0; for (int i=0; i<segs[1]; i++) { for (int j=0; j<segs[0]; j++) { ASSERT_DOUBLE_EQ(fill_seq_2_1, b_data_3[i*segs[0] + j]); fill_seq_2_1++; } } } std::cout << "rank " << my_rank << " reached third barrier in test" << std::endl << std::flush; MPI_Barrier(MPI_COMM_WORLD); std::cout << "rank " << my_rank << " passed third barrier in test" << std::endl << std::flush; }
int luaopen_iso8583(lua_State *L) { luaL_newmetatable(L, "iso8583"); lua_pushvalue(L, -1); lua_setfield(L, -2, "__index"); luaL_register(L, NULL, iso8583lib_m); luaL_register(L, "iso8583", iso8583lib_f); #define set_constant(name, value) lua_pushstring(L, name); lua_pushinteger(L, value); lua_settable(L, -3); set_constant("LEFT", ISO8583_L); set_constant("RIGHT", ISO8583_R); set_constant("L", ISO8583_L); set_constant("R", ISO8583_R); set_constant("ZIP", ISO8583_Z); set_constant("UNZIP", ISO8583_U); set_constant("Z", ISO8583_Z); set_constant("U", ISO8583_U); set_constant("FIX", ISO8583_FIX); set_constant("LLVAR", ISO8583_LLVAR); set_constant("LLLVAR", ISO8583_LLLVAR); return 1; }
/** GCM-specific contract */ void IceModel_PISM::setup_contracts_modele() { // Get arguments we need from coupler auto coupler(dynamic_cast<GCMCoupler_ModelE const *>(this->coupler)); auto params(dynamic_cast<GCMPerIceSheetParams_ModelE const *>(this->gcm_per_ice_sheet_params.get())); printf("BEGIN IceModel_PISM::setup_contracts_modele\n"); IceModel &model(*this); // =========== Transfer constants transfer_constant("standard_gravity", "constant::grav"); transfer_constant("beta_CC", "seaice::dtdp", -1.0); transfer_constant("water_melting_point_temperature", "constant::tf"); transfer_constant("water_latent_heat_fusion", "constant::lhm"); transfer_constant("water_specific_heat_capacity", "constant::shw"); transfer_constant("ice_density", "constant::rhoi"); transfer_constant("ice_thermal_conductivity", "seaice::alami0"); transfer_constant("ice_specific_heat_capacity", "constant::shi"); transfer_constant("fresh_water_density", "constant::rhow"); transfer_constant("sea_water_density", "constant::rhows"); transfer_constant("standard_gravity", "constant::grav"); transfer_constant("ideal_gas_constant", "constant::gasc"); Z2LI = coupler->gcm_constants.get_as("landice::z2li", "m"); // To set this, see (in ModelE): Function SHCGS in ocnfuntab.f is // used for the Russell ocean. I. The simple models use SHW=4185. // This probably doesn't matter much at this point (May 2014) // transfer_constant("sea_water_specific_heat_capacity", ""); /* The following constants were not transferred pism_config:fill_value = -2e9; pism_config:fill_value_doc = "_FillValue used when saving diagnostic quantities"; */ // In PISM and ModelE Clausius-Clapeyron equation, surfce_pressure is the DIFFERENCE // from 1atm. Thus, surface_pressure=0 implies the ice sheet existing at 1atm set_constant("surface_pressure", 0, "Pa"); // Match ModelE thermodynam // No need to set enthalpy_reference_temperature. pism::EnthalpyConverter is used (below) // to convert enthalpy values between ModelE and PISM. // transfer_constant("enthalpy_reference_temperature", "enthalpy_reference_temperature"); // ============ GCM -> Ice CouplingContract &ice_input(contract[IceModel::INPUT]); // ------ Decide on the coupling contract for this ice sheet ice_input.add_field("wflux", "kg m-2 s-1", contracts::ELEVATION, "Downward water flux out of surface model's bottom layer"); ice_input.add_field("massxfer", "kg m-2 s-1", contracts::ELEVATION, "Mass of ice being transferred Stieglitz --> Glint2"); ice_input.add_field("enthxfer", "W m-2", contracts::ELEVATION, "Enthalpy of ice being transferred Stieglitz --> Glint2"); ice_input.add_field("deltah", "W m-2", contracts::ELEVATION, "Change of enthalpy of top layer in PISM"); // Figure out the conversion between GCM and PISM enthalpy // ModelE's reference state is 1atm, 0C, 100% liquid water. // The enthalpy for that reference state would be the top end // of PISM's EnthalpyInterval. // NOTE: Pressure in PISM is RELATIVE to atmospheric pressure. // Thus, p=0 is the correct to use at the top surface of // the ice sheet (where ModelE operates). GLINT2EnthalpyConverter enth(*config); double const pressure = 0; double E_s, E_l; enth.getEnthalpyInterval(pressure, E_s, E_l); double const enth_modele_to_pism = E_l; // (J/kg): Add to convert ModelE specific enthalpies (J/kg) to PISM specific enthalpies (J/kg) // NOTE: enth_modele_to_pism == 437000 J/kg if (pism_rank == 0) printf("enth_modele_to_pism = %g\n", enth_modele_to_pism); bool ok = true; double const RHOW = coupler->gcm_constants.get_as("constant::rhow", "kg m-3"); double const byRHOW = 1.0 / RHOW; // ------------- Convert the contract to a var transformer {VarTransformer &vt(var_transformer[IceModel::INPUT]); vt.set_names(VarTransformer::INPUTS, &coupler->gcm_outputs); vt.set_names(VarTransformer::OUTPUTS, &ice_input); vt.set_names(VarTransformer::SCALARS, &coupler->ice_input_scalars); vt.allocate(); ok = ok && vt.set("wflux", "wflux", "unit", RHOW); ok = ok && vt.set("hflux", "hflux", "unit", 1.0); ok = ok && vt.set("massxfer", "massxfer", "unit", RHOW); ok = ok && vt.set("enthxfer", "enthxfer", "unit", 1.0); ok = ok && vt.set("enthxfer", "massxfer", "unit", enth_modele_to_pism*RHOW); ok = ok && vt.set("volxfer", "volxfer", "unit", 1.0); } // ============== Ice -> GCM CouplingContract &ice_output(contract[IceModel::OUTPUT]); // Glint2 requires that all ice models return elev2, so that it can regrid in the vertical. ice_output.add_field("usurf", "m", contracts::ICE|contracts::INITIAL, "ice upper surface elevation"); // See ice_surface_elevation in iceModel.cc ice_output.add_field("M1", "kg m-2", contracts::ICE|contracts::INITIAL, ""); ice_output.add_field("M2", "kg m-2", contracts::ICE|contracts::INITIAL, ""); ice_output.add_field("H1", "J m-2", contracts::ICE|contracts::INITIAL, ""); ice_output.add_field("H2", "J m-2", contracts::ICE|contracts::INITIAL, ""); ice_output.add_field("V1", "m^3 m-2", contracts::ICE|contracts::INITIAL, ""); ice_output.add_field("V2", "m^3 m-2", contracts::ICE|contracts::INITIAL, ""); ice_output.add_field("basal_frictional_heating", "W m-2", contracts::ICE, ""); ice_output.add_field("strain_heating", "W m-2", contracts::ICE, ""); ice_output.add_field("geothermal_flux", "W m-2", contracts::ICE, ""); ice_output.add_field("upward_geothermal_flux", "W m-2", contracts::ICE, ""); ice_output.add_field("calving.mass", "kg m-2 s-1", contracts::ICE, ""); ice_output.add_field("calving.enth", "W m-2", contracts::ICE, ""); ice_output.add_field("glint2_smb.mass", "kg m-2 s-1", contracts::ICE, ""); ice_output.add_field("glint2_smb.enth", "W m-2", contracts::ICE, ""); ice_output.add_field("glint2_surface_temp", "K", contracts::ICE, ""); ice_output.add_field("pism_smb.mass", "kg m-2 s-1", contracts::ICE, ""); ice_output.add_field("pism_smb.enth", "W m-2", contracts::ICE, ""); // basal_runoff (GCM input) = melt_grounded + melt_floatig (PISM outputs) ice_output.add_field("melt_grounded.mass", "kg m-2 s-1", contracts::ICE, ""); ice_output.add_field("melt_grounded.enth", "W m-2", contracts::ICE, ""); ice_output.add_field("melt_floating.mass", "kg m-2 s-1", contracts::ICE, ""); ice_output.add_field("melt_floating.enth", "W m-2", contracts::ICE, ""); ice_output.add_field("internal_advection.mass", "kg m-2 s-1", contracts::ICE, ""); ice_output.add_field("internal_advection.enth", "W m-2", contracts::ICE, ""); ice_output.add_field("epsilon.mass", "kg m-2 s-1", contracts::ICE, ""); ice_output.add_field("epsilon.enth", "W m-2", contracts::ICE, ""); ice_output.add_field("unit", "", 0, "Dimensionless identity"); std::cout << "========= Ice Model Outputs (" << model.name << ") modele_pism.cpp:" << std::endl; std::cout << ice_output << std::endl; // ------- Variable and unit conversions, Ice -> GCM {VarTransformer &vt(var_transformer[IceModel::OUTPUT]); // NOTE: coupler->gcm_inputs is set up through calls to add_gcm_input_xx() in LANDICE_COM.f vt.set_names(VarTransformer::INPUTS, &ice_output); vt.set_names(VarTransformer::OUTPUTS, &coupler->gcm_inputs); vt.set_names(VarTransformer::SCALARS, &coupler->ice_input_scalars); vt.allocate(); // ok = ok && vt.set("elev2", "usurf", "unit", 1.0); ok = ok && vt.set("elev1", "usurf", "unit", 1.0); // Top layer state from ice model ok = ok && vt.set("M1", "M1", "unit", byRHOW); // Divide by RHOW to convert to m water equiv ok = ok && vt.set("H1", "H1", "unit", 1.0); ok = ok && vt.set("H1", "M1", "unit", -enth_modele_to_pism*byRHOW); ok = ok && vt.set("V1", "V1", "unit", 1.0); // Second-top layer state from ice model ok = ok && vt.set("M1", "M1", "unit", byRHOW); // Divide by RHOW to convert to m water equiv ok = ok && vt.set("H1", "H1", "unit", 1.0); ok = ok && vt.set("H1", "M1", "unit", -enth_modele_to_pism*byRHOW); ok = ok && vt.set("V1", "V1", "unit", 1.0); ok = ok && vt.set("basal_frictional_heating", "basal_frictional_heating", "unit", 1.0); ok = ok && vt.set("strain_heating", "strain_heating", "unit", 1.0); ok = ok && vt.set("geothermal_flux", "geothermal_flux", "unit", 1.0); ok = ok && vt.set("upward_geothermal_flux", "upward_geothermal_flux", "unit", 1.0); ok = ok && vt.set("basal_runoff.mass", "melt_grounded.mass", "unit", 1.0); ok = ok && vt.set("basal_runoff.enth", "melt_grounded.enth", "unit", 1.0); ok = ok && vt.set("basal_runoff.enth", "melt_grounded.mass", "unit", -enth_modele_to_pism); ok = ok && vt.set("basal_runoff.mass", "melt_floating.mass", "unit", 1.0); ok = ok && vt.set("basal_runoff.enth", "melt_floating.enth", "unit", 1.0); ok = ok && vt.set("basal_runoff.enth", "melt_floating.mass", "unit", -enth_modele_to_pism); ok = ok && vt.set("calving.mass", "calving.mass", "unit", 1.0); ok = ok && vt.set("calving.enth", "calving.enth", "unit", 1.0); ok = ok && vt.set("calving.enth", "calving.mass", "unit", -enth_modele_to_pism); ok = ok && vt.set("internal_advection.mass", "internal_advection.mass", "unit", 1.0); ok = ok && vt.set("internal_advection.enth", "internal_advection.enth", "unit", 1.0); ok = ok && vt.set("internal_advection.enth", "internal_advection.mass", "unit", -enth_modele_to_pism); ok = ok && vt.set("epsilon.mass", "epsilon.mass", "unit", 1.0); ok = ok && vt.set("epsilon.enth", "epsilon.enth", "unit", 1.0); ok = ok && vt.set("epsilon.enth", "epsilon.mass", "unit", -enth_modele_to_pism); } // Catch all our errors at once if (!ok) throw std::exception(); printf("END IceModel_PISM::setup_contracts_modele\n"); }