void abort() { stk::EnvData &env_data = stk::EnvData::instance(); // Cannot be sure of parallel synchronization status; therefore, no communications can // occur. Grab and dump all pending output buffers to 'std::cerr'. std::cerr << std::endl << "*** SIERRA ABORT on P" << stk::EnvData::instance().m_parallelRank << " ***" << std::endl << "*** check " << get_param("output-log") << " file for more information ***" << std::endl ; if (!env_data.m_output.str().empty()) { std::cerr << "Buffer contents of deferred output stream on processor " << parallel_rank() << std::endl ; std::cerr << env_data.m_output.str(); } std::cerr.flush(); std::cout.flush(); ::sleep(1); // Give the other processors a chance at // catching up, seems to help hanging problems. #if defined(STK_HAS_MPI) MPI_Abort(env_data.m_parallelComm, MPI_ERR_OTHER); // First try to die #endif std::exit( EXIT_FAILURE ); // Second try to die }
//-------------------------------------------------------------------------- //-------- set_log_file_stream --------------------------------------------- //-------------------------------------------------------------------------- void NaluEnv::set_log_file_stream(std::string naluLogName, bool pprint) { if ( pRank_ == 0 ) { naluStreamBuffer_.open(naluLogName.c_str(), std::ios::out); naluLogStream_->rdbuf(&naluStreamBuffer_); } else { naluLogStream_->rdbuf(&naluEmptyStreamBuffer_); } // default to an empty stream buffer for parallel unless pprint is set parallelLog_ = pprint; if (parallelLog_) { int numPlaces = static_cast<int>(std::log10(pSize_-1)+1); std::stringstream paddedRank; paddedRank << std::setw(numPlaces) << std::setfill('0') << parallel_rank(); // inputname.log -> inputname.log.16.02 for the rank 2 proc of a 16 proc job std::string parallelLogName = naluLogName + "." + std::to_string(pSize_) + "." + paddedRank.str(); naluParallelStreamBuffer_.open(parallelLogName.c_str(), std::ios::out); naluParallelStream_->rdbuf(&naluParallelStreamBuffer_); } else { naluParallelStream_->rdbuf(stdoutStream_); } }
std::string Ioss::ParallelUtils::decode_filename(const std::string &filename, bool is_parallel) const { std::string decoded_filename(filename); if (is_parallel) { // Running in parallel, assume nemesis and decode what the filename // should be for this processor. int processor = parallel_rank(); int num_processors = parallel_size(); decoded_filename = Ioss::Utils::decode_filename(filename, processor, num_processors); } return decoded_filename; }
void Ioss::ParallelUtils::gather(int64_t my_value, std::vector<int64_t> &result) const { if (parallel_rank() == 0) { result.resize(parallel_size()); } #ifdef HAVE_MPI if (parallel_size() > 1) { const int success = MPI_Gather((void*)&my_value, 1, MPI_LONG_LONG_INT, (void*)&result[0], 1, MPI_LONG_LONG_INT, 0, communicator_); if (success != MPI_SUCCESS) { std::ostringstream errmsg; errmsg << "Ioss::ParallelUtils::gather - MPI_Gather failed"; IOSS_ERROR(errmsg); } } else { result[0] = my_value; } #else result[0] = my_value; #endif }
void Ioss::ParallelUtils::gather(std::vector<int64_t> &my_values, std::vector<int64_t> &result) const { size_t count = my_values.size(); if (parallel_rank() == 0) { result.resize(count * parallel_size()); } #ifdef HAVE_MPI if (parallel_size() > 1) { const int success = MPI_Gather((void*)TOPTR(my_values), count, MPI_LONG_LONG_INT, (void*)TOPTR(result), count, MPI_LONG_LONG_INT, 0, communicator_); if (success != MPI_SUCCESS) { std::ostringstream errmsg; errmsg << "Ioss::ParallelUtils::gather - MPI_Gather failed"; IOSS_ERROR(errmsg); } } else { std::copy(my_values.begin(), my_values.end(), result.begin()); } #else std::copy(my_values.begin(), my_values.end(), result.begin()); #endif }
void BulkDataTester::check_sharing_comm_maps() { stk::CommSparse comm(parallel()); for(int phase = 0; phase < 2; ++phase) { for(stk::mesh::EntityCommListInfoVector::const_iterator i = this->my_internal_comm_list().begin(); i != this->my_internal_comm_list().end(); ++i) { for(stk::mesh::PairIterEntityComm ec = this->internal_entity_comm_map(i->key); !ec.empty(); ++ec) { int type = ec->ghost_id; if ( type == 0 ) { std::vector<int> sharingProcs; this->comm_shared_procs(i->key, sharingProcs); // pack shared info int owner = -1; if(bucket_ptr(i->entity) != 0) { owner = parallel_owner_rank(i->entity); } comm.send_buffer(ec->proc).pack<stk::mesh::EntityKey>(i->key).pack<int>(type).pack<int>(owner); comm.send_buffer(ec->proc).pack<size_t>(sharingProcs.size()); for (size_t proc=0;proc<sharingProcs.size();++proc) { comm.send_buffer(ec->proc).pack<int>(sharingProcs[proc]); } } } } if(phase == 0) { comm.allocate_buffers(); } else { comm.communicate(); } } // unpack std::ostringstream os; bool anyErrors = false; for(int i = 0; i < parallel_size(); ++i) { if ( i != parallel_rank() ) { stk::mesh::EntityKey key; int type = -1; int from = -1; int owner = -1; while(comm.recv_buffer(i).remaining()) { from = i; comm.recv_buffer(from).unpack<stk::mesh::EntityKey>(key).unpack<int>(type).unpack<int>(owner); size_t numSharingProcs = 0; comm.recv_buffer(from).unpack<size_t>(numSharingProcs); std::vector<int> sharingProcs(numSharingProcs); for (size_t proc=0;proc<numSharingProcs;++proc) { comm.recv_buffer(from).unpack<int>(sharingProcs[proc]); } std::vector<int> localSharingProcs; this->comm_shared_procs(key, localSharingProcs); std::sort(localSharingProcs.begin(), localSharingProcs.end()); std::sort(sharingProcs.begin(), sharingProcs.end()); size_t maxNum = localSharingProcs.size() + sharingProcs.size(); std::vector<int> unsharedProcs(maxNum); std::vector<int>::iterator iter = std::set_symmetric_difference( localSharingProcs.begin(), localSharingProcs.end(), sharingProcs.begin(), sharingProcs.end(), unsharedProcs.begin()); size_t numUnshared = iter - unsharedProcs.begin(); unsharedProcs.resize(numUnshared); int counter = 0; { for (size_t j=0;j<numUnshared;++j) { std::vector<int>::iterator localIter = std::find(sharingProcs.begin(), sharingProcs.end(), unsharedProcs[j]); if ( localIter != sharingProcs.end() && *localIter != parallel_rank() ) { if ( counter == 0 ) { os << "Error in sharing between procs for entity " << key.id() << " with rank " << key.rank() << " between procs: " << this->parallel_rank() << " and " << from << std::endl; counter++; } os << "\tEntity " << key << " is shared with proc " << unsharedProcs[j] << " from other proc: " << from << " but not from this proc: " << parallel_rank() << std::endl; anyErrors = true; } localIter = std::find(localSharingProcs.begin(), localSharingProcs.end(), unsharedProcs[j]); if ( localIter != localSharingProcs.end() && *localIter != from ) { if ( counter == 0 ) { os << "Error in sharing between procs for entity " << key.id() << " with rank " << key.rank() << " between procs: " << this->parallel_rank() << " and " << from << std::endl; counter++; } os << "\tEntity " << key << " is shared with proc " << unsharedProcs[j] << " from this proc: " << parallel_rank() << " but not from other proc: " << from << std::endl; anyErrors = true; } } } } } } ThrowRequireMsg(!anyErrors, os.str()); }