void FeatureFloodCount::communicateAndMerge()
{
// First we need to transform the raw data into a usable data structure
prepareDataForTransfer();
/*********************************************************************************
*********************************************************************************
* Begin Parallel Communication Section
*********************************************************************************
*********************************************************************************/
/**
* The libMesh packed range routines handle the communication of the individual
* string buffers. Here we need to create a container to hold our type
* to serialize. It'll always be size one because we are sending a single
* byte stream of all the data to other processors. The stream need not be
* the same size on all processors.
*/
std::vector<std::string> send_buffers(1);
/**
* Additionally we need to create a different container to hold the received
* byte buffers. The container type need not match the send container type.
* However, We do know the number of incoming buffers (num processors) so we'll
* go ahead and use a vector.
*/
std::vector<std::string> recv_buffers;
recv_buffers.reserve(_app.n_processors());
serialize(send_buffers[0]);
/**
* Each processor needs information from all other processors to create a complete
* global feature map.
*/
_communicator.allgather_packed_range((void *)(nullptr), send_buffers.begin(), send_buffers.end(),
std::back_inserter(recv_buffers));
deserialize(recv_buffers);
/*********************************************************************************
*********************************************************************************
* End Parallel Communication Section
*********************************************************************************
*********************************************************************************/
mergeSets(true);
}
void FeatureFloodCount::communicateAndMerge()
{
// First we need to transform the raw data into a usable data structure
prepareDataForTransfer();
/**
* The libMesh packed range routines handle the communication of the individual
* string buffers. Here we need to create a container to hold our type
* to serialize. It'll always be size one because we are sending a single
* byte stream of all the data to other processors. The stream need not be
* the same size on all processors.
*/
std::vector<std::string> send_buffers(1);
/**
* Additionally we need to create a different container to hold the received
* byte buffers. The container type need not match the send container type.
* However, We do know the number of incoming buffers (num processors) so we'll
* go ahead and use a vector.
*/
std::vector<std::string> recv_buffers;
if (_is_master)
recv_buffers.reserve(_app.n_processors());
serialize(send_buffers[0]);
// Free up as much memory as possible here before we do global communication
clearDataStructures();
/**
* Send the data from all processors to the root to create a complete
* global feature map.
*/
_communicator.gather_packed_range(0, (void *)(nullptr), send_buffers.begin(), send_buffers.end(),
std::back_inserter(recv_buffers));
if (_is_master)
{
// The root process now needs to deserialize and merge all of the data
deserialize(recv_buffers);
recv_buffers.clear();
mergeSets(true);
}
// Make sure that feature count is communicated to all ranks
_communicator.broadcast(_feature_count);
}
