loadBalancer.h

Go to the documentation of this file.

/*  This file is part of the OpenLB library
 *
 *  Copyright (C) 2007, 2014 Mathias Krause, Peter Weisbrod
 *  E-mail contact: info@openlb.net
 *  The most recent release of OpenLB can be downloaded at
 *  <http://www.openlb.net/>
 *
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License
 *  as published by the Free Software Foundation; either version 2
 *  of the License, or (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public
 *  License along with this program; if not, write to the Free
 *  Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 *  Boston, MA  02110-1301, USA.
*/
 
 
#ifndef LOAD_BALANCER_H
#define LOAD_BALANCER_H
 
#include <vector>
#include <map>
 
#include "core/singleton.h"
#include "core/serializer.h"
#include "io/xmlReader.h"
#include "core/platform/platform.h"
 
namespace olb {
 
 
//template<typename T, typename BaseType> class Vector;
template<typename T> class CuboidGeometry3D;
template<typename T> class CuboidGeometry2D;
template<typename T> class HeuristicLoadBalancer;
 
template<typename T>
class LoadBalancer : public BufferSerializable {
protected:
  int _size;
  std::map<int,int> _loc;
  std::vector<int>  _glob;
  std::map<int,int> _rank;
  std::map<int,Platform> _platform;
 
public:
  LoadBalancer(int size=1);
  LoadBalancer(int size, std::map<int,int>& loc, std::vector<int>& glob, std::map<int,int>& rank);
  LoadBalancer(int size, std::map<int,int>& loc, std::vector<int>& glob, std::map<int,int>& rank, std::map<int,Platform>& platform);
  virtual ~LoadBalancer();
  void swap(LoadBalancer<T>& loadBalancer);
  bool isLocal(const int& glob);
  int loc(const int& glob);
  int loc(int glob) const;
  int glob(int loc) const;
  int rank(const int& glob);
  int rank(int glob) const;
  int size() const;
  int getRankSize() const;
 
  virtual Platform platform(int loc) const {
    auto iter = _platform.find(glob(loc));
    if (iter != _platform.end()) {
      return std::get<1>(*iter);
    } else {
    #ifdef PLATFORM_GPU_CUDA
      return Platform::GPU_CUDA;
    #else
    #ifdef PLATFORM_CPU_SIMD
      return Platform::CPU_SIMD;
    #else
      return Platform::CPU_SISD;
    #endif
    #endif
    }
  }
 
  virtual void setPlatform(int loc, Platform platform) {
    _platform[glob(loc)] = platform;
  }
 
  bool operator==(const LoadBalancer<T>& rhs) const;
 
  std::size_t getNblock() const override;
  std::size_t getSerializableSize() const override;
  bool* getBlock(std::size_t iBlock, std::size_t& sizeBlock, bool loadingMode) override;
 
  void print(bool multiOutput = false) const;
 
};
 
 
//    or within the reader (XML tag) itself. Either choice is saved in lbXml.
template<typename T>
LoadBalancer<T>* createLoadBalancer(XMLreader const& xmlReader, CuboidGeometry3D<T>* cGeo = NULL)
{
  OstreamManager clout(std::cout, "createLoadBalancer");
  std::string defaultMode = "Block";
 
  LoadBalancer<T>* lb; // The LoadBalancer to be returned
 
  // Read file attribute to decide if a new XML reader has to be created
  XMLreader const* lbXml;
  std::string fileAttr = xmlReader.getAttribute("file");
  bool newFile = ( fileAttr != "Attribute not found." );
  if ( newFile ) {
    lbXml = new XMLreader(fileAttr);
  }
  else {
    lbXml = &xmlReader;
  }
 
  bool verbose = false;
  (*lbXml).setWarningsOn(false);
 
  std::string mode = lbXml->getAttribute("mode");
  if ( mode == "Attribute not found.") {
    clout << "Warning: Cannot read parameter from Xml-file: Mode. Set default: mode = " << defaultMode << std::endl;
    mode = defaultMode;
  }
 
  // Heuristic Mode
  if ( mode == "Heuristic" ) {
    // only read ratioFullEmpty - Heuristic LB will constructed from cuboidGeometry deterministicly
    double ratioFullEmpty;
    if (!(*lbXml)["RatioFullEmpty"].read<double>(ratioFullEmpty, verbose)) {
      lb = new HeuristicLoadBalancer<T>(*cGeo);
    }
    else {
      lb = new HeuristicLoadBalancer<T>(*cGeo, ratioFullEmpty);
    }
  }
 
  // Base Mode
  else if ( mode == "Base" ) {
    //LoadBalancer<T>* loadBalancer = new LoadBalancer<T>();
    //loadBalancer->load(fileName);
    clout << "LOADING BASE LB NOT IMPLEMENTED YET!" << std::endl;
    (*lbXml).setWarningsOn(true);
    //return loadBalancer;
    lb = NULL;
  }
 
  // Block Mode
  else if ( mode == "Block" ) {
    int size = 1;
    if (!(*lbXml)["Size"].read<int>(size, verbose)) {
      clout << "Warning: Cannot read parameter from Xml-file: Size. Set default: size = 1"
            << std::endl;
    }
    lb = new LoadBalancer<T>(size);
  }
 
 
  (*lbXml).setWarningsOn(true);
 
  // Delete XMLreader if it was created for the LB file
  if ( newFile ) {
    delete lbXml;
  }
 
  return lb;
}
 
 
template<typename T>
LoadBalancer<T>* createLoadBalancer(std::string const& fileName, CuboidGeometry3D<T>* cGeo = NULL)
{
  std::string fname = singleton::directories().getLogOutDir() + fileName + ".xml";
  XMLreader lbReader(fname);
  return createLoadBalancer(lbReader["LoadBalancer"], cGeo);
}
 
}  // namespace olb
 
#endif