scotchpartitioner.hh

Go to the documentation of this file.

// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set et ts=4 sw=4 sts=4:
//
// SPDX-FileCopyrightInfo: Copyright © DuMux Project contributors, see AUTHORS.md in root folder
// SPDX-License-Identifier: GPL-3.0-or-later
//
 
#ifndef DUMUX_PARALLEL_SCOTCH_PARTITIONER_HH
#define DUMUX_PARALLEL_SCOTCH_PARTITIONER_HH
 
#include <string>
#include <vector>
#include <iostream>
 
#include <dune/common/exceptions.hh>
#include <dumux/linear/scotchbackend.hh>
 
namespace Dumux {
 
#if HAVE_PTSCOTCH
 
class ScotchGraphMapStrategy
{
public:
    ScotchGraphMapStrategy(std::size_t numProcessors, double imbalanceRatio = 0.0, int flag = SCOTCH_STRATDEFAULT)
    {
        if (SCOTCH_stratInit(&strategy_) != 0)
            DUNE_THROW(Dune::Exception, "Error initializing SCOTCH strategy!");
 
        if (SCOTCH_stratGraphMapBuild(&strategy_,  static_cast<SCOTCH_Num>(flag), static_cast<SCOTCH_Num>(numProcessors), imbalanceRatio) != 0)
            DUNE_THROW(Dune::Exception, "Error building SCOTCH strategy!");
    }
 
    ~ScotchGraphMapStrategy()
    {
        SCOTCH_stratExit(&strategy_);
    }
 
    SCOTCH_Strat* data()
    { return &strategy_; }
 
private:
    SCOTCH_Strat strategy_;
};
 
#endif // HAVE_PTSCOTCH
 
template<class IndexType = int>
class ScotchPartitioner
{
public:
    using Graph = std::vector<std::vector<IndexType>>;
 
    static std::vector<IndexType> partition(const Graph& graph, std::size_t numProcessors)
    {
        std::vector<IndexType> targetProcessors;
        partition(graph, numProcessors, targetProcessors);
        return targetProcessors;
    }
 
    static void partition(const Graph& graph, std::size_t numProcessors,
                          std::vector<IndexType>& targetProcessors)
    {
#if HAVE_PTSCOTCH
        ScotchGraph<IndexType> scotchGraph(graph);
        ScotchGraphMapStrategy strategy(numProcessors);
 
        // architecture and graphMap are created and called within graphPart
        // if specific ones are desired, one has to call them separately and delete the graphPart function call
        // compute partitioning
        const auto graphSize = graph.size();
        std::vector<SCOTCH_Num> scotchPartitions(graphSize);
        if (SCOTCH_graphPart(scotchGraph.data(), static_cast<SCOTCH_Num>(numProcessors), strategy.data(), scotchPartitions.data()) != 0)
            DUNE_THROW(Dune::Exception, "Error computing SCOTCH graph mapping!");
 
        // convert number types
        targetProcessors = std::vector<IndexType>(
            scotchPartitions.begin(), scotchPartitions.end()
        );
#endif // HAVE_PTSCOTCH
    }
};
 
} // end namespace Dumux
 
#endif