DistributionMapping.H

Go to the documentation of this file.

/*
** (c) 1996-2000 The Regents of the University of California (through
** E.O. Lawrence Berkeley National Laboratory), subject to approval by
** the U.S. Department of Energy.  Your use of this software is under
** license -- the license agreement is attached and included in the
** directory as license.txt or you may contact Berkeley Lab's Technology
** Transfer Department at TTD@lbl.gov.  NOTICE OF U.S. GOVERNMENT RIGHTS.
** The Software was developed under funding from the U.S. Government
** which consequently retains certain rights as follows: the
** U.S. Government has been granted for itself and others acting on its
** behalf a paid-up, nonexclusive, irrevocable, worldwide license in the
** Software to reproduce, prepare derivative works, and perform publicly
** and display publicly.  Beginning five (5) years after the date
** permission to assert copyright is obtained from the U.S. Department of
** Energy, and subject to any subsequent five (5) year renewals, the
** U.S. Government is granted for itself and others acting on its behalf
** a paid-up, nonexclusive, irrevocable, worldwide license in the
** Software to reproduce, prepare derivative works, distribute copies to
** the public, perform publicly and display publicly, and to permit
** others to do so.
*/

#ifndef BL_DISTRIBUTIONMAPPING_H
#define BL_DISTRIBUTIONMAPPING_H
//
// $Id: DistributionMapping.H,v 1.22 2001/07/31 17:56:26 lijewski Exp $
//
#include <vector>

#include <BoxLib.H>
#include <Array.H>
#include <Box.H>

class BoxArray;

//
// :

class DistributionMapping
{
  public:
    //
    //
    enum Strategy { ROUNDROBIN, KNAPSACK };
    //
    //
    DistributionMapping ();
    //
    //
    DistributionMapping (const BoxArray& boxes, int nprocs);
    //
    // This is a very specialized distribution map.
    // Do NOT use it unless you really understand what it does.
    //
    DistributionMapping (const DistributionMapping& d1,
                         const DistributionMapping& d2);

    DistributionMapping (const BoxArray& boxes,int nprocs,
                         int* procmapping);
    //
    //
    ~DistributionMapping ();

    void define (const BoxArray& boxes, int nprocs);

    const Array<int>& ProcessorMap () const;
    //
    //
    int operator[] (int index) const;
    //
    //
    static void strategy (Strategy how);
    //
    //
    static Strategy strategy ();

    static void FlushCache ();
    //
    //
    static int CacheSize ();
    //
    //
    static void AddToCache (const DistributionMapping& dm);
    //
    //
    static void CacheStats (std::ostream& os);
    //
    //
    bool operator== (const DistributionMapping& rhs) const;
    //
    //
    bool operator!= (const DistributionMapping& rhs) const;

    void RoundRobinProcessorMap (int nboxes, int nprocs);
    void KnapSackProcessorMap   (const std::vector<long>& boxes, int nprocs);
    //
    // Initializes distribution strategy from ParmParse.
    //
    // ParmParse options are:
    //
    //   DistributionMapping.strategy = ROUNDROBIN
    //   DistributionMapping.strategy = KNAPSACK
    //
    static void Initialize ();

    static void Finalize ();

private:
    //
    // Two ways to create the processor map.
    //
    void RoundRobinProcessorMap   (const BoxArray& boxes, int nprocs);
    void KnapSackProcessorMap     (const BoxArray& boxes, int nprocs);

    //
    // Our cache of processor maps.
    //
    static std::vector< Array<int> > m_Cache;
    //
    // Look for a cached processor map.
    //
    bool GetMap (const BoxArray& boxes);
    //
    // A useful typedef.
    //
    typedef void (DistributionMapping::*PVMF)(const BoxArray&,int);
    //
    // Everyone uses the same Strategy -- defaults to KNAPSACK.
    //
    static Strategy m_Strategy;
    //
    // Pointer to one of the CreateProcessorMap() functions.
    // Corresponds to the one specified by `m_Strategy'.
    //
    static PVMF m_BuildMap;
    //
    // Have we initialized from ParmParse yet?
    //
    static bool m_Initialized;
    //
    // Local data -- our processor map.
    //
    // The length is always equal to boxes.length()+1 where `boxes' is
    // the BoxArray on which the distribution is based.  It is also true
    // that m_procmap[boxes.length()] == ParallelDescriptor::MyProc().
    // This latter acts as a sentinel in some FabArray loops.
    //
    Array<int> m_procmap;
};

//
// Our output operator.
//
std::ostream& operator<< (std::ostream& os, const DistributionMapping& pmap);

#endif /*BL_DISTRIBUTIONMAPPING_H*/

---