ColorBasedTraversal.h

Go to the documentation of this file.

 
#pragma once
 
#include "autopas/containers/TraversalInterface.h"
#include "autopas/containers/cellTraversals/CellTraversal.h"
#include "autopas/options/InteractionTypeOption.h"
#include "autopas/utils/ArrayMath.h"
#include "autopas/utils/DataLayoutConverter.h"
#include "autopas/utils/ThreeDimensionalMapping.h"
#include "autopas/utils/WrapOpenMP.h"
 
namespace autopas {
 
template <class ParticleCell, class Functor, int collapseDepth = 3>
class ColorBasedTraversal : public CellTraversal<ParticleCell>, public TraversalInterface {
 protected:
  explicit ColorBasedTraversal(const std::array<unsigned long, 3> &dims, Functor *functor,
                               const double interactionLength, const std::array<double, 3> &cellLength,
                               DataLayoutOption dataLayout, bool useNewton3)
      : CellTraversal<ParticleCell>(dims),
        TraversalInterface(dataLayout, useNewton3),
        _interactionLength(interactionLength),
        _cellLength(cellLength),
        _dataLayoutConverter(functor, dataLayout) {
    for (unsigned int d = 0; d < 3; d++) {
      _overlap[d] = std::ceil(_interactionLength / _cellLength[d]);
    }
  }
 
  ~ColorBasedTraversal() override = default;
 
 public:
  void initTraversal() override {
    if (this->_cells) {
      auto &cells = *(this->_cells);
      AUTOPAS_OPENMP(parallel for)
      for (size_t i = 0; i < cells.size(); ++i) {
        _dataLayoutConverter.loadDataLayout(cells[i]);
      }
    }
  }
 
  void endTraversal() override {
    if (this->_cells) {
      auto &cells = *(this->_cells);
      AUTOPAS_OPENMP(parallel for)
      for (size_t i = 0; i < cells.size(); ++i) {
        _dataLayoutConverter.storeDataLayout(cells[i]);
      }
    }
  }
 
 protected:
  template <typename LoopBody>
  inline void colorTraversal(LoopBody &&loopBody, const std::array<unsigned long, 3> &end,
                             const std::array<unsigned long, 3> &stride,
                             const std::array<unsigned long, 3> &offset = {0ul, 0ul, 0ul});
 
  virtual void notifyColorChange(unsigned long newColor){};
 
  const double _interactionLength;
 
  const std::array<double, 3> _cellLength;
 
  std::array<unsigned long, 3> _overlap;
 
 private:
  utils::DataLayoutConverter<Functor> _dataLayoutConverter;
};
 
template <class ParticleCell, class Functor, int collapseDepth>
template <typename LoopBody>
inline void ColorBasedTraversal<ParticleCell, Functor, collapseDepth>::colorTraversal(
    LoopBody &&loopBody, const std::array<unsigned long, 3> &end, const std::array<unsigned long, 3> &stride,
    const std::array<unsigned long, 3> &offset) {
  using namespace autopas::utils::ArrayMath::literals;
  AUTOPAS_OPENMP(parallel) {
    const unsigned long numColors = stride[0] * stride[1] * stride[2];
    for (unsigned long col = 0; col < numColors; ++col) {
      AUTOPAS_OPENMP(single) {
        // barrier at omp for of previous loop iteration, so fine to change it for everyone!
        notifyColorChange(col);
        // implicit barrier at end of function.
      }
      const std::array<unsigned long, 3> startWithoutOffset(utils::ThreeDimensionalMapping::oneToThreeD(col, stride));
      const std::array<unsigned long, 3> start(startWithoutOffset + offset);
 
      // intel compiler demands following:
      const unsigned long start_x = start[0], start_y = start[1], start_z = start[2];
      const unsigned long end_x = end[0], end_y = end[1], end_z = end[2];
      const unsigned long stride_x = stride[0], stride_y = stride[1], stride_z = stride[2];
      if (collapseDepth == 2) {
        AUTOPAS_OPENMP(for schedule(dynamic, 1) collapse(2))
        for (unsigned long z = start_z; z < end_z; z += stride_z) {
          for (unsigned long y = start_y; y < end_y; y += stride_y) {
            for (unsigned long x = start_x; x < end_x; x += stride_x) {
              // Don't exchange order of execution (x must be last!), it would break other code
              loopBody(x, y, z);
            }
          }
        }
      } else {
        AUTOPAS_OPENMP(for schedule(dynamic, 1) collapse(3))
        for (unsigned long z = start_z; z < end_z; z += stride_z) {
          for (unsigned long y = start_y; y < end_y; y += stride_y) {
            for (unsigned long x = start_x; x < end_x; x += stride_x) {
              // Don't exchange order of execution (x must be last!), it would break other code
              loopBody(x, y, z);
            }
          }
        }
      }
    }
  }
}
 
}  // namespace autopas