AutoPasConfigurationCommunicator.h

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <cstddef>
#include <vector>
 
#include "WrapMPI.h"
#include "autopas/containers/ParticleContainerInterface.h"
#include "autopas/tuning/Configuration.h"
#include "autopas/utils/ExceptionHandler.h"
#include "autopas/utils/NumberSet.h"
#include "autopas/utils/SimilarityFunctions.h"
 
namespace autopas::utils::AutoPasConfigurationCommunicator {
 
using SerializedConfiguration = std::array<std::byte, 14>;
 
template <typename TOption>
inline std::byte castToByte(TOption option) {
  return static_cast<std::byte>(static_cast<typename TOption::Value>(option));
}
 
size_t getSearchSpaceSize(const std::set<ContainerOption> &containerOptions, const NumberSet<double> &cellSizeFactors,
                          const std::set<TraversalOption> &traversalOptions,
                          const std::set<LoadEstimatorOption> &loadEstimatorOptions,
                          const std::set<DataLayoutOption> &dataLayoutOptions,
                          const std::set<Newton3Option> &newton3Options,
                          const InteractionTypeOption &interactionTypeOption);
 
void distributeConfigurations(std::set<ContainerOption> &containerOptions, NumberSet<double> &cellSizeFactors,
                              std::set<TraversalOption> &traversalOptions,
                              std::set<LoadEstimatorOption> &loadEstimatorOptions,
                              std::set<DataLayoutOption> &dataLayoutOptions, std::set<Newton3Option> &newton3Options,
                              InteractionTypeOption interactionTypeOption, int rank, int commSize);
 
void distributeRanksInBuckets(AutoPas_MPI_Comm comm, AutoPas_MPI_Comm *bucket, double smoothedHomogeneity,
                              double maxDensity, double MPITuningMaxDifferenceForBucket,
                              double MPITuningWeightForMaxDensity);
 
SerializedConfiguration serializeConfiguration(Configuration configuration);
 
std::vector<std::byte> serializeConfigurations(const std::vector<Configuration> &configurations);
 
Configuration deserializeConfiguration(SerializedConfiguration config);
 
std::vector<Configuration> deserializeConfigurations(const std::vector<std::byte> &configurationsSerialized);
 
Configuration findGloballyBestConfiguration(AutoPas_MPI_Comm comm, Configuration localOptimalConfig,
                                            long localOptimalTime);
 
std::vector<Configuration> gatherConfigurations(AutoPas_MPI_Comm comm,
                                                const std::vector<Configuration> &localConfigurations, int root);
 
}  // namespace autopas::utils::AutoPasConfigurationCommunicator