Add some distribution strategies

Author: franzpoeschel

include/openPMD/Chunk.hpp

@@ -23,6 +23,7 @@
 #include <vector>
 
 #include "openPMD/Dataset.hpp" // Offset, Extent
+#include "openPMD/benchmark/mpi/BlockSlicer.hpp"
 
 namespace openPMD
 {
@@ -73,4 +74,120 @@ struct WrittenChunkInfo : ChunkInfo
 };
 
 using ChunkTable = std::vector< WrittenChunkInfo >;
+
+namespace chunk_assignment
+{
+    constexpr char const * HOSTFILE_VARNAME = "MPI_WRITTEN_HOSTFILE";
+
+    using RankMeta = std::map< unsigned int, std::string >;
+
+    struct PartialAssignment
+    {
+        ChunkTable notAssigned;
+        ChunkTable assigned;
+
+        explicit PartialAssignment() = default;
+        PartialAssignment( ChunkTable notAssigned );
+        PartialAssignment( ChunkTable notAssigned, ChunkTable assigned );
+    };
+
+    struct Strategy
+    {
+        virtual ChunkTable
+        assign(
+            PartialAssignment,
+            RankMeta const & in,
+            RankMeta const & out ) = 0;
+
+        virtual ~Strategy() = default;
+    };
+
+    struct PartialStrategy
+    {
+        virtual PartialAssignment
+        assign(
+            PartialAssignment,
+            RankMeta const & in,
+            RankMeta const & out ) = 0;
+
+        virtual ~PartialStrategy() = default;
+    };
+
+    ChunkTable
+    assignChunks(
+        ChunkTable,
+        RankMeta const & rankMetaIn,
+        RankMeta const & rankMetaOut,
+        Strategy & strategy );
+
+    struct FromPartialStrategy : Strategy
+    {
+        FromPartialStrategy(
+            std::unique_ptr< PartialStrategy > firstPass,
+            std::unique_ptr< Strategy > secondPass );
+
+        virtual ChunkTable
+        assign( PartialAssignment, RankMeta const & in, RankMeta const & out );
+
+    private:
+        std::unique_ptr< PartialStrategy > m_firstPass;
+        std::unique_ptr< Strategy > m_secondPass;
+    };
+
+    struct RoundRobin : Strategy
+    {
+        ChunkTable
+        assign( PartialAssignment, RankMeta const & in, RankMeta const & out );
+    };
+
+    struct ByHostname : PartialStrategy
+    {
+        ByHostname( std::unique_ptr< Strategy > withinNode );
+
+        PartialAssignment
+        assign( PartialAssignment, RankMeta const & in, RankMeta const & out )
+            override;
+
+    private:
+        std::unique_ptr< Strategy > m_withinNode;
+    };
+
+    struct ByCuboidSlice : Strategy
+    {
+        ByCuboidSlice(
+            std::unique_ptr< BlockSlicer > blockSlicer,
+            Extent totalExtent,
+            unsigned int mpi_rank,
+            unsigned int mpi_size );
+
+        ChunkTable
+        assign( PartialAssignment, RankMeta const & in, RankMeta const & out )
+            override;
+
+    private:
+        std::unique_ptr< BlockSlicer > blockSlicer;
+        Extent totalExtent;
+        unsigned int mpi_rank, mpi_size;
+    };
+
+    struct BinPacking : Strategy
+    {
+        ChunkTable
+        assign( PartialAssignment, RankMeta const & in, RankMeta const & out )
+            override;
+    };
+} // namespace chunk_assignment
+
+namespace host_info
+{
+    enum class Method
+    {
+        HOSTNAME
+    };
+
+    std::string byMethod( Method );
+
+    std::string
+    hostname();
+} // namespace host_info
 } // namespace openPMD

include/openPMD/auxiliary/MPI.hpp

@@ -0,0 +1,144 @@
+#pragma once
+
+#if openPMD_HAVE_MPI
+
+#    include <mpi.h>
+#    include <string>
+#    include <vector>
+
+namespace openPMD
+{
+namespace auxiliary
+{
+    inline
+    std::vector< std::string >
+    collectStringsTo(
+        MPI_Comm communicator,
+        int destRank,
+        std::string const & thisRankString )
+    {
+        int rank, size;
+        MPI_Comm_rank( communicator, &rank );
+        MPI_Comm_size( communicator, &size );
+        int sendLength = thisRankString.size() + 1;
+
+        int * sizesBuffer = nullptr;
+        int * displs = nullptr;
+        if( rank == destRank )
+        {
+            sizesBuffer = new int[ size ];
+            displs = new int[ size ];
+        }
+
+        MPI_Gather(
+            &sendLength,
+            1,
+            MPI_INT,
+            sizesBuffer,
+            1,
+            MPI_INT,
+            destRank,
+            MPI_COMM_WORLD );
+
+        char * namesBuffer = nullptr;
+        if( rank == destRank )
+        {
+            size_t sum = 0;
+            for( int i = 0; i < size; ++i )
+            {
+                displs[ i ] = sum;
+                sum += sizesBuffer[ i ];
+            }
+            namesBuffer = new char[ sum ];
+        }
+
+        MPI_Gatherv(
+            thisRankString.c_str(),
+            sendLength,
+            MPI_CHAR,
+            namesBuffer,
+            sizesBuffer,
+            displs,
+            MPI_CHAR,
+            destRank,
+            MPI_COMM_WORLD );
+
+        if( rank == destRank )
+        {
+            std::vector< std::string > hostnames( size );
+            for( int i = 0; i < size; ++i )
+            {
+                hostnames[ i ] = std::string( namesBuffer + displs[ i ] );
+            }
+
+            delete[] sizesBuffer;
+            delete[] displs;
+            delete[] namesBuffer;
+            return hostnames;
+        }
+        else
+        {
+            return std::vector< std::string >();
+        }
+    }
+
+    inline
+    std::vector< std::string >
+    distributeStringsToAllRanks(
+        MPI_Comm communicator,
+        std::string const & thisRankString )
+    {
+        int rank, size;
+        MPI_Comm_rank( communicator, &rank );
+        MPI_Comm_size( communicator, &size );
+        int sendLength = thisRankString.size() + 1;
+
+        int * sizesBuffer = new int[ size ];
+        int * displs = new int[ size ];
+
+        MPI_Allgather(
+            &sendLength,
+            1,
+            MPI_INT,
+            sizesBuffer,
+            1,
+            MPI_INT,
+            MPI_COMM_WORLD );
+
+        char * namesBuffer;
+        {
+            size_t sum = 0;
+            for( int i = 0; i < size; ++i )
+            {
+                displs[ i ] = sum;
+                sum += sizesBuffer[ i ];
+            }
+            namesBuffer = new char[ sum ];
+        }
+
+        MPI_Allgatherv(
+            thisRankString.c_str(),
+            sendLength,
+            MPI_CHAR,
+            namesBuffer,
+            sizesBuffer,
+            displs,
+            MPI_CHAR,
+            MPI_COMM_WORLD );
+
+        std::vector< std::string > hostnames( size );
+        for( int i = 0; i < size; ++i )
+        {
+            hostnames[ i ] = std::string( namesBuffer + displs[ i ] );
+        }
+
+        delete[] sizesBuffer;
+        delete[] displs;
+        delete[] namesBuffer;
+        return hostnames;
+        
+    }
+} // namespace auxiliary
+} // namespace openPMD
+
+#endif