TileMapping.hpp

Go to the documentation of this file.

// Copyright (c) 2017 Graphcore Ltd. All rights reserved.
#ifndef poputil_TileMapping_hpp
#define poputil_TileMapping_hpp
#include "poplar/DebugContext.hpp"
#include "poplar/Graph.hpp"
#include "poplar/Tensor.hpp"
#include <vector>
 
namespace poputil {
 
std::vector<std::vector<poplar::Interval>>
calcLinearTileMapping(const poplar::Graph &graph,
                      std::vector<std::size_t> shape,
                      unsigned minElementsPerTile, unsigned grainSize,
                      unsigned offset = 0, bool ascendingOrder = true);
 
std::vector<std::vector<poplar::Interval>>
calcLinearTileMapping(const poplar::Graph &graph, const poplar::Tensor &t,
                      unsigned offset = 0, bool ascendingOrder = true);
 
std::pair<poplar::Graph::TileToTensorMapping, unsigned>
calcLinearTileMappingAndNewOffset(const poplar::Graph &graph,
                                  const poplar::Tensor &t, unsigned offset = 0);
 
void mapTensorLinearly(poplar::Graph &graph, const poplar::Tensor &t,
                       unsigned minElementsPerTile, unsigned grainSize);
 
void mapTensorLinearlyWithOffset(poplar::Graph &graph, const poplar::Tensor &t,
                                 unsigned minElementsPerTile,
                                 unsigned grainSize, unsigned offset,
                                 bool ascendingOrder = true);
 
void mapTensorLinearly(poplar::Graph &graph, const poplar::Tensor &t);
 
void mapTensorLinearlyWithOffset(poplar::Graph &graph, const poplar::Tensor &t,
                                 unsigned offset = 0,
                                 bool ascendingOrder = true);
 
std::size_t chooseMappingOffset(std::size_t numTiles,
                                const std::vector<std::size_t> &shape);
 
std::size_t chooseMappingOffset(std::size_t numTiles,
                                const std::vector<std::size_t> &shape,
                                std::size_t seed);
 
unsigned getTileImbalance(const poplar::Graph::TileToTensorMapping &mapping,
                          unsigned minElementsPerTile = 0,
                          unsigned grainSize = 1);
 
unsigned getTileImbalance(const poplar::Graph &graph, const poplar::Tensor &t,
                          unsigned minElementsPerTile = 0,
                          unsigned grainSize = 1);
 
class TensorUseTrackerState;
 
class TensorUseTracker {
  std::unique_ptr<TensorUseTrackerState> st;
 
public:
  TensorUseTracker(unsigned numTiles, unsigned startTile = 0,
                   bool ascendingMappingOrder = true);
 
  TensorUseTracker(const TensorUseTracker &other);
 
  TensorUseTracker(TensorUseTracker &&other);
 
  TensorUseTracker &operator=(const TensorUseTracker &other);
 
  TensorUseTracker &operator=(TensorUseTracker &&other);
 
  enum class MappingMethod {
    OptimizeHaloRegions,
 
    ConstrainMappingToUsedTiles,
 
    None
  };
 
  ~TensorUseTracker();
 
  void add(const poplar::Graph &graph, unsigned tile, const poplar::Tensor &t);
 
  void add(TensorUseTracker other);
 
  void resolve(const poplar::Graph &graph, unsigned grainSize,
               unsigned minElementsPerTile, bool extendPartialUsage = false,
               TensorUseTracker::MappingMethod mappingMethod =
                   TensorUseTracker::MappingMethod::None);
 
  void mapTensorsByUse(poplar::Graph &graph, unsigned grainSize,
                       unsigned minElementsPerTile,
                       bool extendPartialUsage = false,
                       TensorUseTracker::MappingMethod mappingMethod =
                           TensorUseTracker::MappingMethod::None);
 
  bool empty() const;
};
 
poplar::Tensor
cloneToIpu(poplar::Graph &graph, const poplar::Tensor &t, unsigned dstIPU,
           const poplar::DebugContext &debugContext = {},
           poplar::TensorCloneMethod method =
               poplar::TensorCloneMethod::PRESERVE_ORDER_UNLESS_ALIASES);
 
poplar::Tensor
cloneToGraph(poplar::Graph &srcGraph, poplar::Graph &dstGraph,
             const poplar::Tensor &t,
             const poplar::DebugContext &debugContext = {},
             poplar::TensorCloneMethod method =
                 poplar::TensorCloneMethod::PRESERVE_ORDER_UNLESS_ALIASES);
 
std::pair<poplar::Tensor, unsigned>
cloneAndExpandAliasing(poplar::Graph &graph, const poplar::Tensor &t,
                       unsigned offset = 0,
                       const poplar::DebugContext &debugContext = {});
 
poplar::Tensor
copyToIpu(poplar::Graph &masterGraph, const poplar::Tensor &t,
          poplar::program::Sequence &prog, unsigned dstIPU,
          const poplar::DebugContext &debugContext = {},
          poplar::TensorCloneMethod method =
              poplar::TensorCloneMethod::PRESERVE_ORDER_UNLESS_ALIASES);
 
poplar::Tensor
createIpuCopy(poplar::Graph &graph, const poplar::Tensor &t, unsigned dstIpu,
              poplar::Tensor &copySrc, poplar::Tensor &copyDst,
              const poplar::DebugContext &debugContext = {},
              poplar::TensorCloneMethod method =
                  poplar::TensorCloneMethod::PRESERVE_ORDER_AND_ALIASES);
 
bool dimIsSplitOverTiles(const poplar::Graph &graph, const poplar::Tensor &t,
                         unsigned dimension);
 
bool dimIsSplitOverIPUs(const poplar::Graph &graph, const poplar::Tensor &t,
                        unsigned dimension);
 
poplar::Tensor
createBroadcastOperand(poplar::Graph &graph, const poplar::Tensor &fullTensor,
                       const poplar::Type &type, unsigned dim,
                       bool ditherMapping = false,
                       const poplar::DebugContext &debugContext = {});
 
unsigned transformTileIndex(unsigned tile, unsigned numTiles, unsigned offset,
                            bool ascending);
 
unsigned invTransformTileIndex(unsigned tile, unsigned numTiles,
                               unsigned offset, bool ascending);
 
} // namespace poputil
 
#endif // poputil_TileMapping_hpp