Util.hpp

Go to the documentation of this file.

// Copyright (c) 2016 Graphcore Ltd. All rights reserved.
#ifndef poputil_Util_hpp
#define poputil_Util_hpp
 
#include <algorithm>
#include <cassert>
#include <climits>
#include <poplar/Device.hpp>
#include <poplar/Graph.hpp>
#include <poplar/Interval.hpp>
#include <poplar/Program.hpp>
#include <poplar/Quarter.hpp>
#include <poplar/Target.hpp>
#include <poplar/Tensor.hpp>
#include <string>
#include <vector>
 
namespace poputil {
 
void mergeAdjacentRegions(std::vector<poplar::Interval> &regions);
 
void mergeAdjacentRegions(std::vector<std::vector<poplar::Interval>> &mapping);
 
std::vector<poplar::Interval>
flattenIntervals(const std::vector<std::vector<poplar::Interval>> &intervals);
 
std::vector<std::vector<poplar::Interval>>
splitRegions(const std::vector<poplar::Interval> &regions, unsigned grainSize,
             unsigned maxPartitions, unsigned minElementsPerPartition = 0,
             unsigned maxElementsPerPartition = UINT_MAX,
             unsigned maxElementsPerRegion = UINT_MAX);
 
std::vector<std::vector<poplar::Interval>> splitRegionsBetweenWorkers(
    const poplar::Target &target, const std::vector<poplar::Interval> &regions,
    unsigned grainSize, unsigned minElementsPerPartition = 0,
    unsigned maxElementsPerPartition = UINT_MAX,
    unsigned maxElementsPerRegion = UINT_MAX);
 
std::vector<std::vector<std::vector<poplar::Interval>>>
splitRegions(const std::vector<std::vector<poplar::Interval>> &regions,
             unsigned grainSize, unsigned maxPartitions,
             unsigned minElementsPerPartition = 0,
             unsigned maxElementsPerPartition = UINT_MAX,
             unsigned maxElementsPerRegion = UINT_MAX);
 
std::vector<std::vector<std::vector<poplar::Interval>>>
splitRegionsBetweenWorkers(
    const poplar::Target &target,
    const std::vector<std::vector<poplar::Interval>> &regions,
    unsigned grainSize, unsigned minElementsPerPartition = 0,
    unsigned maxElementsPerPartition = UINT_MAX,
    unsigned maxElementsPerRegion = UINT_MAX);
 
template <class T>
std::vector<T> unflattenIndex(const std::vector<T> &shape, std::size_t index) {
  std::vector<T> coord(shape.size());
 
  for (std::size_t i = shape.size(); i > 0; --i) {
    coord[i - 1] = index % shape[i - 1];
    index /= shape[i - 1];
  }
 
  assert(index == 0);
  return coord;
}
 
template <class T>
std::size_t flattenIndex(const std::vector<T> &shape,
                         const std::vector<T> &indices) {
  auto rank = shape.size();
  assert(indices.size() == rank);
  std::size_t index = 0;
  for (unsigned i = 0; i != rank; ++i) {
    index = index * shape[i] + indices[i];
  }
  return index;
}
 
std::size_t intervalSequenceNumElements(
    const std::vector<std::vector<poplar::Interval>> &seq);
 
poplar::Tensor
duplicate(poplar::Graph &graph, const poplar::Tensor &in,
          poplar::program::Sequence &p,
          const poplar::DebugContext &debugContext = {},
          poplar::TensorCloneMethod method =
              poplar::TensorCloneMethod::PRESERVE_ORDER_UNLESS_ALIASES);
 
poplar::Tensor
cloneN(poplar::Graph &graph, const poplar::Tensor &t, unsigned N,
       const poplar::DebugContext &debugContext = {},
       poplar::TensorCloneMethod method =
           poplar::TensorCloneMethod::PRESERVE_ORDER_UNLESS_ALIASES);
 
std::vector<int> balancedPartition(int rangeUpperBound, int splitCount);
 
double castToDeviceHalfValue(const poplar::Target &target, double input);
 
bool checkAccuracyWhenCast(const poplar::Target &target, double input,
                           poplar::Type inputType, poplar::Type outputType,
                           double tolerance);
 
poplar::Tensor factorDims(const poplar::Tensor &t,
                          const std::vector<std::size_t> &factors,
                          unsigned startDim = 0);
 
poplar::Tensor unfactorDims(const poplar::Tensor &t, unsigned numDims,
                            unsigned startDim = 0);
 
// Create metadata for use with FP8 data types
poplar::Tensor
createConstantMetadataTensor(poplar::Graph &graph,
                             poplar::QuarterMetadata::Format fp8Format,
                             int fp8Scale);
 
poplar::Tensor
createVariableMetadataTensor(poplar::Graph &graph,
                             poplar::QuarterMetadata::Format fp8Format,
                             int fp8Scale);
 
std::vector<poplar::Interval>
calculateUnshufflingIntervals(const std::vector<poplar::Interval> &intervals);
 
} // end namespace poputil
 
#endif // poputil_Util_hpp