latest/doxygen/IPUModel_8hpp_source.html

// Copyright (c) 2017 Graphcore Ltd. All rights reserved.


#ifndef poplar_IPUModel_hpp

#define poplar_IPUModel_hpp

#include <poplar/Device.hpp>

#include <poplar/OptionFlags.hpp>

#include <poplar/Target.hpp>


namespace poplar {


struct IPUModel {

  explicit IPUModel(char const *IPUVersion = "ipu2");

  std::string IPUVersion;

  unsigned numIPUs;

  unsigned tilesPerSuperTile;

  unsigned tilesPerIPU;

  unsigned numWorkerContexts;

  unsigned memoryBytesPerTile;

  double tileClockFrequency;

  unsigned exchangeBytesPerCycle;

  unsigned memcpyBytesPerCycle;

  unsigned instructionBytes;

  bool supportsSuperTileSendReceive;

  unsigned interleavedMemoryElementIndex;

  enum class RelativeSyncDelayType { AUTO, NO_DELAY } relativeSyncDelay;

  unsigned minIPUSyncDelay;

  unsigned globalSyncCycles;

  std::vector<GlobalExchangeConstraint> globalExchangeConstraints;

  unsigned globalExchangePacketBytes;

  unsigned tileLocalSyncSyncDelay;

  unsigned tileLocalSyncExitDelay;

  unsigned numStrideBits;

  unsigned dataPathWidth;

  unsigned fp8ConvUnitMaxPipelineDepth;

  unsigned fp16ConvUnitMaxPipelineDepth;

  unsigned fp32ConvUnitMaxPipelineDepth;

  unsigned fp8ConvUnitInputLoadElemsPerCycle;

  unsigned fp16ConvUnitInputLoadElemsPerCycle;

  unsigned fp32ConvUnitInputLoadElemsPerCycle;

  unsigned fp16InFp16OutConvUnitsPerTile;

  unsigned fp16InFp32OutConvUnitsPerTile;

  unsigned fp32InFp32OutConvUnitsPerTile;

  unsigned fp8InFp16OutConvUnitsPerTile;

  unsigned convUnitCoeffLoadBytesPerCycle;

  unsigned supervisorInstrFetchDelay;

  unsigned workerInstrFetchDelay;

  unsigned maxImmediateOffsetInRunInstr;


  // Max number of repeat counter

  unsigned rptCountMax;

  unsigned atomicStoreGranularity;

  bool compileIPUCode;


  bool operator==(const IPUModel &) const;

  bool operator!=(const IPUModel &) const;


  Device

  createDevice(OptionFlags opts = {}, bool accurateHalf = false,

               unsigned deviceManagerId = std::numeric_limits<unsigned>::max());

};


} // namespace poplar


#endif // poplar_IPUModel_hpp

poplar::Device
A device refers to a physical entity that can execute code.
Definition: Device.hpp:26

poplar::OptionFlags
A set of option/value string flags to be used in various APIs.
Definition: OptionFlags.hpp:24

ipu::max
half2 max(half2 src0, half2 src1)
Targets the f16v2max instruction.
Definition: ipu_intrinsics:333

poplar
Poplar classes and functions.
Definition: ArrayRef.hpp:14

poplar::IPUModel
A model of an IPU to create an IPUModel Device The IPU Model will simulate the behaviour of the IPU h...
Definition: IPUModel.hpp:14

poplar::IPUModel::fp16ConvUnitInputLoadElemsPerCycle
unsigned fp16ConvUnitInputLoadElemsPerCycle
The input elements loaded per cycle for f16 conv.
Definition: IPUModel.hpp:84

poplar::IPUModel::atomicStoreGranularity
unsigned atomicStoreGranularity
The atomic store granularity.
Definition: IPUModel.hpp:114

poplar::IPUModel::globalExchangeConstraints
std::vector< GlobalExchangeConstraint > globalExchangeConstraints
Set of constraints that provide a lower bound on the time it takes to send data between IPUs.
Definition: IPUModel.hpp:59

poplar::IPUModel::fp8ConvUnitInputLoadElemsPerCycle
unsigned fp8ConvUnitInputLoadElemsPerCycle
The input elements loaded per cycle for f8 conv.
Definition: IPUModel.hpp:82

poplar::IPUModel::createDevice
Device createDevice(OptionFlags opts={}, bool accurateHalf=false, unsigned deviceManagerId=std::numeric_limits< unsigned >::max())
Create a device that runs code on the CPU and models the performance that would be achieved on an IPU...

poplar::IPUModel::fp16ConvUnitMaxPipelineDepth
unsigned fp16ConvUnitMaxPipelineDepth
The maximum pipeline depth of the convolution units within the tile for fp16.
Definition: IPUModel.hpp:77

poplar::IPUModel::workerInstrFetchDelay
unsigned workerInstrFetchDelay
Number of bytes worker context may be loading instructions from memory ahead of current PC.
Definition: IPUModel.hpp:106

poplar::IPUModel::memcpyBytesPerCycle
unsigned memcpyBytesPerCycle
The number of bytes per cycle that can be copied from one location to another using a memcpy.
Definition: IPUModel.hpp:35

poplar::IPUModel::fp32InFp32OutConvUnitsPerTile
unsigned fp32InFp32OutConvUnitsPerTile
The number of convolution units in the tile that can be used when accumulating to 32 bit values.
Definition: IPUModel.hpp:95

poplar::IPUModel::dataPathWidth
unsigned dataPathWidth
The width of the load/store data path within the tile.
Definition: IPUModel.hpp:71

poplar::IPUModel::fp8InFp16OutConvUnitsPerTile
unsigned fp8InFp16OutConvUnitsPerTile
The number of convolution units in the tile that can be used when partial results are outputs as 16-b...
Definition: IPUModel.hpp:98

poplar::IPUModel::tilesPerSuperTile
unsigned tilesPerSuperTile
The number of tiles per supertile.
Definition: IPUModel.hpp:22

poplar::IPUModel::IPUVersion
std::string IPUVersion
Valid values for IPUVersion are "ipu1" and "ipu2" (for Mk1 and Mk2 IPU architectures respectively)
Definition: IPUModel.hpp:18

poplar::IPUModel::supervisorInstrFetchDelay
unsigned supervisorInstrFetchDelay
Number of bytes supervisor contexts may be loading instructions from memory ahead of current PC.
Definition: IPUModel.hpp:103

poplar::IPUModel::tileLocalSyncSyncDelay
unsigned tileLocalSyncSyncDelay
Number of cycles from issuing a sync instruction to the earliest time that instructions can resume.
Definition: IPUModel.hpp:64

poplar::IPUModel::numStrideBits
unsigned numStrideBits
Number of stride bits.
Definition: IPUModel.hpp:69

poplar::IPUModel::numIPUs
unsigned numIPUs
The number of IPUs.
Definition: IPUModel.hpp:20

poplar::IPUModel::memoryBytesPerTile
unsigned memoryBytesPerTile
Memory bytes per tile.
Definition: IPUModel.hpp:28

poplar::IPUModel::RelativeSyncDelayType
RelativeSyncDelayType
A function that returns the number of cycles before the specificed tile is released from sync relativ...
Definition: IPUModel.hpp:52

poplar::IPUModel::instructionBytes
unsigned instructionBytes
The size of an instruction in bytes.
Definition: IPUModel.hpp:37

poplar::IPUModel::fp16InFp32OutConvUnitsPerTile
unsigned fp16InFp32OutConvUnitsPerTile
The number of convolution units in the tile that can be used when partial results are outputs as 32-b...
Definition: IPUModel.hpp:92

poplar::IPUModel::tileLocalSyncExitDelay
unsigned tileLocalSyncExitDelay
Number of cycles after a worker has issued its exit instruction that the supervisor can resume.
Definition: IPUModel.hpp:67

poplar::IPUModel::compileIPUCode
bool compileIPUCode
Whether or not to actually compile real IPU code for modelling.
Definition: IPUModel.hpp:116

poplar::IPUModel::tileClockFrequency
double tileClockFrequency
Clock frequency in Hz.
Definition: IPUModel.hpp:30

poplar::IPUModel::maxImmediateOffsetInRunInstr
unsigned maxImmediateOffsetInRunInstr
max range of immediate operand in run instruction zimm16 operand multiplied implicitly by 4 when adde...
Definition: IPUModel.hpp:109

poplar::IPUModel::fp32ConvUnitInputLoadElemsPerCycle
unsigned fp32ConvUnitInputLoadElemsPerCycle
The input elements loaded per cycle for f32 conv.
Definition: IPUModel.hpp:86

poplar::IPUModel::convUnitCoeffLoadBytesPerCycle
unsigned convUnitCoeffLoadBytesPerCycle
The number of convolutional weights that can be loaded in a cycle.
Definition: IPUModel.hpp:100

poplar::IPUModel::fp32ConvUnitMaxPipelineDepth
unsigned fp32ConvUnitMaxPipelineDepth
The maximum pipeline depth of the convolution units within the tile for fp32.
Definition: IPUModel.hpp:80

poplar::IPUModel::tilesPerIPU
unsigned tilesPerIPU
The number of tiles per IPU.
Definition: IPUModel.hpp:24

poplar::IPUModel::supportsSuperTileSendReceive
bool supportsSuperTileSendReceive
Whether a tile in a supertile can use all the exchange bandwidth of the supertile to send or receive,...
Definition: IPUModel.hpp:41

poplar::IPUModel::fp16InFp16OutConvUnitsPerTile
unsigned fp16InFp16OutConvUnitsPerTile
The number of convolution units in the tile that can be used when partial results are outputs as 16-b...
Definition: IPUModel.hpp:89

poplar::IPUModel::exchangeBytesPerCycle
unsigned exchangeBytesPerCycle
The bandwidth of internal IPU exchange in bytes per cycle.
Definition: IPUModel.hpp:32

poplar::IPUModel::fp8ConvUnitMaxPipelineDepth
unsigned fp8ConvUnitMaxPipelineDepth
The maximum pipeline depth of the convolution units within the tile for fp8.
Definition: IPUModel.hpp:74

poplar::IPUModel::globalExchangePacketBytes
unsigned globalExchangePacketBytes
Size of the packet used to transfer data between tiles in bytes.
Definition: IPUModel.hpp:61

poplar::IPUModel::numWorkerContexts
unsigned numWorkerContexts
The number of worker contexts per tile.
Definition: IPUModel.hpp:26

poplar::IPUModel::interleavedMemoryElementIndex
unsigned interleavedMemoryElementIndex
Index in the memoryElementOffsets table (returned by Target::getMemoryElementOffsets) which gives the...
Definition: IPUModel.hpp:48

poplar::IPUModel::globalSyncCycles
unsigned globalSyncCycles
The number of clock cycles required to synchronize all IPUs.
Definition: IPUModel.hpp:56

poplar::IPUModel::minIPUSyncDelay
unsigned minIPUSyncDelay
The IPU sync delay for the tile that is closest to the sync controller.
Definition: IPUModel.hpp:54