int main(int argc, char **argv) { // feenableexcept(FE_DIVBYZERO); // feenableexcept(FE_OVERFLOW); // feenableexcept(FE_INVALID); // // signal(SIGSEGV, bt_sighandler); // signal(SIGFPE, bt_sighandler); // signal(SIGTERM, bt_sighandler); // signal(SIGINT, bt_sighandler); // signal(SIGABRT, bt_sighandler); #ifdef HAVE_MPI MPI_Init(&argc, &argv); int num_procs; sip::SIPMPIUtils::check_err(MPI_Comm_size(MPI_COMM_WORLD, &num_procs), __LINE__,__FILE__); if (num_procs < 2) { std::cerr << "Please run this test with at least 2 mpi ranks" << std::endl; return -1; } sip::SIPMPIUtils::set_error_handler(); sip::SIPMPIAttr &sip_mpi_attr = sip::SIPMPIAttr::get_instance(); attr = &sip_mpi_attr; #endif barrier(); #ifdef HAVE_TAU TAU_PROFILE_SET_NODE(0); TAU_STATIC_PHASE_START("SIP Main"); #endif // sip::check(sizeof(int) >= 4, "Size of integer should be 4 bytes or more"); // sip::check(sizeof(double) >= 8, "Size of double should be 8 bytes or more"); // sip::check(sizeof(long long) >= 8, "Size of long long should be 8 bytes or more"); // // int num_procs; // sip::SIPMPIUtils::check_err(MPI_Comm_size(MPI_COMM_WORLD, &num_procs)); // // if (num_procs < 2){ // std::cerr<<"Please run this test with at least 2 mpi ranks"<<std::endl; // return -1; // } // // sip::SIPMPIUtils::set_error_handler(); // sip::SIPMPIAttr &sip_mpi_attr = sip::SIPMPIAttr::get_instance(); // printf("Running main() from test_sial.cpp\n"); testing::InitGoogleTest(&argc, argv); barrier(); int result = RUN_ALL_TESTS(); std::cout << "Rank " << attr->global_rank() << " Finished RUN_ALL_TEST() " << std::endl << std::flush; #ifdef HAVE_TAU TAU_STATIC_PHASE_STOP("SIP Main"); #endif barrier(); #ifdef HAVE_MPI MPI_Finalize(); #endif return result; }
int main(int argc, char * argv[]) { TAU_INIT(&argc, &argv) TAU_PROFILE_TIMER(orio_maintimer, "main()", "int (int, char **)", TAU_USER); TAU_PROFILE_START(orio_maintimer); TAU_PROFILE_SET_NODE(0); std::vector<viennacl::ocl::device> devices = viennacl::ocl::platform().devices(); std::vector<cl_device_id> my_devices; my_devices.push_back(devices[0].id()); viennacl::ocl::setup_context(0L, my_devices); //Change this type definition to double if your gpu supports that typedef double ScalarType; ///////////////////////////////////////////////// ///////////// Vector operations ///////////////// ///////////////////////////////////////////////// void * orio_profiler; TAU_PROFILER_CREATE(orio_profiler, "orio_generated_code", "", TAU_USER); for(int i = 0; i < 3; ++i) { // // Define a few vectors (from STL and plain C) and viennacl::vectors // std::vector<ScalarType> std_vec1(1000000); std::vector<ScalarType> std_vec2(1000000); viennacl::vector<ScalarType> vcl_vec1(1000000); viennacl::vector<ScalarType> vcl_vec2(1000000); viennacl::scalar<ScalarType> vcl_s1 = ScalarType(5.0); // // Let us fill the CPU vectors with random values: // (random<> is a helper function from Random.hpp) // for (unsigned int i = 0; i < 1000000; ++i) { std_vec1[i] = random<ScalarType>(); std_vec2[i] = 0.0; } // // Copy the CPU vectors to the GPU vectors and vice versa // TAU_PROFILER_START(orio_profiler); viennacl::copy(std_vec1.begin(), std_vec1.end(), vcl_vec1.begin()); //either the STL way viennacl::copy(std_vec2.begin(), std_vec2.end(), vcl_vec2.begin()); //either the STL way vcl_vec2 += vcl_s1 * vcl_vec1; viennacl::copy(vcl_vec2.begin(), vcl_vec2.end(), std_vec2.begin()); TAU_PROFILER_STOP(orio_profiler); } double orio_inclusive[TAU_MAX_COUNTERS]; TAU_PROFILER_GET_INCLUSIVE_VALUES(orio_profiler, &orio_inclusive); printf("{'/*@ coordinate @*/' : %g}\n", orio_inclusive[0]); return EXIT_SUCCESS; }
int main (int argc, char *argv[]) { validate_input(argc, argv); /* * Initialize TAU and start a timer for the main function. */ TAU_INIT(&argc, &argv); TAU_PROFILE_SET_NODE(0); TAU_PROFILE_TIMER(tautimer, __func__, my_name, TAU_USER); TAU_PROFILE_START(tautimer); /* * Initialize MPI. We don't require threaded support, but with threads * we can send the TAU data over SOS asynchronously. */ int rc = MPI_SUCCESS; int provided = 0; rc = MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided); if (rc != MPI_SUCCESS) { char *errorstring; int length = 0; MPI_Error_string(rc, errorstring, &length); fprintf(stderr, "Error: MPI_Init failed, rc = %d\n%s\n", rc, errorstring); fflush(stderr); exit(99); } MPI_Comm_rank(MPI_COMM_WORLD, &my_rank); MPI_Comm_size(MPI_COMM_WORLD, &comm_size); my_printf("%s %s %d Running with comm_size %d\n", argv[0], my_name, getpid(), comm_size); MPI_Comm adios_comm; MPI_Comm_dup(MPI_COMM_WORLD, &adios_comm); adios_init ("arrays.xml", adios_comm); /* * Loop and do the things */ int iter = 0; char tmpstr[256] = {0}; int * return_codes = (int *)(calloc(num_sources,sizeof(int))); while (iter < iterations) { int index; /* * Read upstream input */ for (index = 0 ; index < num_sources ; index++) { if (return_codes[index] > 0) { my_printf("%s source is gone\n", sources[index]); continue; // this input is gone } my_printf ("%s reading from %s.\n", my_name, sources[index]); sprintf(tmpstr,"%s READING FROM %s", my_name, sources[index]); TAU_START(tmpstr); //mpi_reader(adios_comm, sources[index]); return_codes[index] = flexpath_reader(adios_comm, index); TAU_STOP(tmpstr); } /* * "compute" */ my_printf ("%s computing.\n", my_name); compute(iter); bool time_to_go = (num_sources == 0) ? (iter == (iterations-1)) : true; for (index = 0 ; index < num_sources ; index++) { if (return_codes[index] == 0) { time_to_go = false; break; // out of this for loop } } /* * Send output downstream */ for (index = 0 ; index < num_sinks ; index++) { my_printf ("%s writing to %s.\n", my_name, sinks[index]); sprintf(tmpstr,"%s WRITING TO %s", my_name, sinks[index]); TAU_START(tmpstr); //mpi_writer(adios_comm, sinks[index]); flexpath_writer(adios_comm, index, (iter > 0), time_to_go); TAU_STOP(tmpstr); } if (time_to_go) { break; // out of the while loop } my_printf ("%s not time to go...\n", my_name); iter++; } /* * Finalize ADIOS */ const char const * dot_filename = ".finished"; if (num_sources > 0) { adios_read_finalize_method(ADIOS_READ_METHOD_FLEXPATH); #if 0 } else { while (true) { // assume this is the main process. It can't exit until // the last process is done. if( access( dot_filename, F_OK ) != -1 ) { // file exists unlink(dot_filename); break; } else { // file doesn't exist sleep(1); } } #endif } if (num_sinks > 0) { adios_finalize (my_rank); #if 0 } else { // assume this is the last process. // Tell the main process we are done. FILE *file; if (file = fopen(dot_filename, "w")) { fprintf(file, "done.\n"); fclose(file); } #endif } /* * Finalize MPI */ MPI_Comm_free(&adios_comm); MPI_Finalize(); my_printf ("%s Done.\n", my_name); TAU_PROFILE_STOP(tautimer); return 0; }
virtual void initialize(){ TAU_PROFILE_SET_NODE(0); }