/home/brandes/workspace/LAMA/src/lama/distribution/Distribution.hpp

Go to the documentation of this file.

#ifndef LAMA_DISTRIBUTION_HPP_
#define LAMA_DISTRIBUTION_HPP_

// for dll_import
#include <lama/config.hpp>

// base classes
#include <lama/NonCopyable.hpp>
#include <lama/Printable.hpp>

// others
#include <lama/LAMATypes.hpp>
#include <lama/Communicator.hpp>

// logging
#include <logging/logging.hpp>

// boost
#include <boost/shared_ptr.hpp>

namespace lama
{

typedef boost::shared_ptr<const class Distribution> DistributionPtr;

class LAMA_DLL_IMPORTEXPORT Distribution : public Printable,
                                           private NonCopyable
{
public:

    Distribution( const IndexType globalSize,
                  const CommunicatorPtr communicator );

    Distribution( const IndexType globalSize );

    virtual ~Distribution();

    const Communicator& getCommunicator() const;

    CommunicatorPtr getCommunicatorPtr() const;

    PartitionId getNumPartitions() const;

    bool isReplicated() const { return getNumPartitions() == 1; }

    virtual bool isLocal( const IndexType index ) const = 0;

    inline IndexType getGlobalSize() const;

    virtual IndexType getLocalSize() const = 0;

    virtual IndexType local2global( const IndexType localIndex ) const = 0;

    virtual IndexType global2local( const IndexType globalIndex ) const = 0;

    virtual void computeOwners(
        const std::vector<IndexType>& requiredIndexes,
        std::vector<PartitionId>& owners ) const;

    virtual bool isEqual( const Distribution& other ) const = 0;

    virtual void writeAt( std::ostream& stream ) const;

    bool operator==( const Distribution& other ) const;

    bool operator!=( const Distribution& other ) const;

    /* Replication of distributed data, one entry for each element of the global range
     *
     * @param[out] allValues  array over the global range will contain all values
     * @param[in]  localValues  array over the local range has only values for each partition
     */

    template<typename T1, typename T2>
    void replicate( T1* allValues, const T2* localValues ) const;

    /* Replication of distributed data, one line of n entries for each element of the global range
     *
     * @param[out] allValues  array over the global range will contain all values
     * @param[in]  localValues  array over the local range has only values for each partition
     * @param[in]  n is number of entries in each line of data
     */

    template<typename T1, typename T2>
    void replicateN( T1* allValues, const T2* localValues, const IndexType n) const;

    /* Replication of distributed data, several entries for each element of the global range
     *
     * @param[out] allValues array with all values from all partitions
     * @param[in] allOffsets  contains the offset for each element of the global range
     * @param[in] localValues elements available on this partition
     *
     * Note: the size of allValues must be globalSize + 1, allOffsets[globalSize] is total number of values
     *
     * The offset array is used like in CSR sparse matrix storage for offsets and number of values.
     */

    template<typename T>
    void replicate( T* allValues, const IndexType* allOffsets, const T* localValues ) const;

    virtual void printDistributionVector( std::string name ) const = 0;

protected:

    IndexType mGlobalSize;
    CommunicatorPtr mCommunicator;

private:

    Distribution();   // disable default constructor

    LAMA_LOG_DECL_STATIC_LOGGER( logger );
};

IndexType Distribution::getGlobalSize() const
{
    return mGlobalSize;
}

}

#endif // LAMA_DISTRIBUTION_HPP_