├── .ci └── view_component_trigger │ ├── Jenkinsfile │ └── jobs.groovy ├── .clang-format ├── .github ├── CODEOWNERS └── workflows │ └── pre-commit.yaml ├── .gitignore ├── .pre-commit-config.yaml ├── CMakeLists.txt ├── License.txt ├── README.md ├── cbt.json ├── cmake └── Modules │ ├── AddGPLibrary.cmake │ └── Findzoltan.cmake ├── exported_symbols_linux.lds ├── exported_symbols_osx.lds ├── include ├── popfloat │ └── experimental │ │ ├── CastToGfloat.hpp │ │ ├── CastToHalf.hpp │ │ ├── GfloatExpr.hpp │ │ ├── GfloatExprUtil.hpp │ │ └── codelets.hpp ├── popfloat_mock │ ├── Mock.hpp │ └── MockFixture.hpp ├── poplibs_support │ ├── Algorithms.hpp │ ├── CTCInferenceDefs.hpp │ ├── Compiler.hpp │ ├── ContiguousRegionsByTile.hpp │ ├── ExternalCodelet.hpp │ ├── FlopEstimation.hpp │ ├── HashTuple.hpp │ ├── IclUtil.hpp │ ├── LogArithmetic.hpp │ ├── Memoize.hpp │ ├── MultiArray.hpp │ ├── PlanConstraints.hpp │ ├── StridedRegions.hpp │ ├── TestDevice.hpp │ ├── TraceChannels.hpp │ ├── Tracepoint.hpp │ ├── VectorUtils.hpp │ ├── Visitor.hpp │ ├── codelets.hpp │ ├── forceInterleavedEstimates.hpp │ ├── logging.hpp │ ├── print.hpp │ └── vv_iterator.hpp ├── poplibs_test │ ├── CTCInference.hpp │ ├── CTCLoss.hpp │ ├── CTCUtil.hpp │ ├── Check.hpp │ ├── Convolution.hpp │ ├── Embedding.hpp │ ├── FullyConnected.hpp │ ├── GeneralMatrixAdd.hpp │ ├── GeneralMatrixMultiply.hpp │ ├── Gru.hpp │ ├── Lstm.hpp │ ├── MatrixTransforms.hpp │ ├── Multirate.hpp │ ├── NonLinearity.hpp │ ├── Norms.hpp │ ├── Pass.hpp │ ├── Pooling.hpp │ ├── ProgressBar.hpp │ ├── ROIAlign.hpp │ ├── Reduce.hpp │ ├── Rnn.hpp │ ├── SparseMatrix.hpp │ ├── TempDir.hpp │ ├── Util.hpp │ └── exceptions.hpp ├── poplin │ ├── Cholesky.hpp │ ├── ConvParams.hpp │ ├── ConvPreplan.hpp │ ├── ConvUtil.hpp │ ├── Convolution.hpp │ ├── FullyConnected.hpp │ ├── MatMul.hpp │ ├── MeshGrid.hpp │ ├── MultiConvolution.hpp │ ├── Norms.hpp │ ├── TriangularSolve.hpp │ ├── codelets.hpp │ └── experimental │ │ ├── LuFactorization.hpp │ │ └── QRFactorization.hpp ├── poplin_mock │ ├── Mock.hpp │ └── MockFixture.hpp ├── popnn │ ├── BatchNorm.hpp │ ├── CTCInference.hpp │ ├── CTCLoss.hpp │ ├── CTCPlan.hpp │ ├── GroupNorm.hpp │ ├── Gru.hpp │ ├── GruDef.hpp │ ├── InstanceNorm.hpp │ ├── LayerNorm.hpp │ ├── LogSoftmax.hpp │ ├── Loss.hpp │ ├── Lstm.hpp │ ├── LstmDef.hpp │ ├── NonLinearity.hpp │ ├── NonLinearityDef.hpp │ ├── NonLinearityDefUtil.hpp │ ├── Norms.hpp │ ├── Pooling.hpp │ ├── PoolingDef.hpp │ ├── Recurrent.hpp │ ├── Rnn.hpp │ ├── SpatialSoftMax.hpp │ ├── codelets.hpp │ └── experimental │ │ └── ROIAlign.hpp ├── popnn_mock │ ├── Mock.hpp │ └── MockFixture.hpp ├── popops │ ├── AllTrue.hpp │ ├── Cast.hpp │ ├── CircBuf.hpp │ ├── DynamicSlice.hpp │ ├── ElementWise.hpp │ ├── ElementWiseUtil.hpp │ ├── Encoding.hpp │ ├── EncodingConstants.hpp │ ├── Expr.hpp │ ├── ExprOp.hpp │ ├── ExprOpUtils.hpp │ ├── Fill.hpp │ ├── Gather.hpp │ ├── GatherStatistics.hpp │ ├── HostSliceTensor.hpp │ ├── Loop.hpp │ ├── NaN.hpp │ ├── NormaliseImage.hpp │ ├── Operation.hpp │ ├── OperationDef.hpp │ ├── OperationDefUtil.hpp │ ├── Pad.hpp │ ├── PerformanceEstimation.hpp │ ├── Rearrange.hpp │ ├── Reduce.hpp │ ├── ScaledAdd.hpp │ ├── Scatter.hpp │ ├── SelectScalarFromRows.hpp │ ├── SequenceSlice.hpp │ ├── Sort.hpp │ ├── SortOrder.hpp │ ├── SplineBasis.hpp │ ├── SplineWeighting.hpp │ ├── TopK.hpp │ ├── UpdateScalarInRows.hpp │ ├── Zero.hpp │ └── codelets.hpp ├── popops_mock │ ├── Matchers.hpp │ ├── Mock.hpp │ └── MockFixture.hpp ├── poprand │ ├── RandomGen.hpp │ └── codelets.hpp ├── poprand_mock │ ├── Mock.hpp │ └── MockFixture.hpp ├── popsparse │ ├── Embedding.hpp │ ├── FullyConnected.hpp │ ├── FullyConnectedParams.hpp │ ├── MatMul.hpp │ ├── MatMulParams.hpp │ ├── PlanningCache.hpp │ ├── SparsePartitioner.hpp │ ├── SparseStorageFormats.hpp │ ├── SparseTensor.hpp │ ├── SparsityParams.hpp │ ├── codelets.hpp │ └── experimental │ │ ├── BlockSparse.hpp │ │ └── BlockSparseMatMul.hpp ├── poputil │ ├── Broadcast.hpp │ ├── DebugInfo.hpp │ ├── GraphFunction.hpp │ ├── OptionParsing.hpp │ ├── TensorMetaData.hpp │ ├── TileMapping.hpp │ ├── Util.hpp │ ├── VarStructure.hpp │ ├── VertexTemplates.hpp │ ├── cyclesTables.hpp │ └── exceptions.hpp └── poputil_mock │ ├── Mock.hpp │ └── MockFixture.hpp ├── lib ├── CMakeLists.txt ├── popfloat │ ├── CMakeLists.txt │ ├── CastToGfloat.cpp │ ├── CastToHalf.cpp │ ├── GfloatExprUtil.cpp │ ├── codelets.cpp │ ├── codelets │ │ ├── CastFloatToGf16.cpp │ │ ├── CastFloatToGf8.cpp │ │ ├── CastGf16ToFloat.cpp │ │ ├── CastGf8ToFloat.cpp │ │ ├── CastGf8ToHalf.cpp │ │ ├── CastHalfToGf8.cpp │ │ ├── CastToGfloat16.cpp │ │ ├── CastToGfloat16InPlace.cpp │ │ ├── CastToGfloat16Param.cpp │ │ ├── CastToGfloat16Sr.cpp │ │ ├── CastToGfloat16SrInPlace.cpp │ │ ├── CastToGfloat32.cpp │ │ ├── CastToGfloat32InPlace.cpp │ │ ├── CastToGfloat32Param.cpp │ │ ├── CastToGfloat32Sr.cpp │ │ ├── CastToGfloat32SrInPlace.cpp │ │ ├── PackedGfloatParams.cpp │ │ ├── asm │ │ │ ├── CastFloatToGF16.S │ │ │ ├── CastFloatToGF16.h │ │ │ ├── CastFloatToGF8.S │ │ │ ├── CastFloatToGF8.h │ │ │ ├── CastGF16ToFloat.S │ │ │ ├── CastGF16ToFloat.h │ │ │ ├── CastGF8ToFloat.S │ │ │ ├── CastGF8ToFloat.h │ │ │ ├── CastGF8ToHalf.S │ │ │ ├── CastGF8ToHalf.h │ │ │ ├── CastHalfToGF8.S │ │ │ ├── CastHalfToGF8.h │ │ │ ├── CastToGfloat16.S │ │ │ ├── CastToGfloat16.h │ │ │ ├── CastToGfloat16Param.S │ │ │ ├── CastToGfloat16Param.h │ │ │ ├── CastToGfloat16Sr.S │ │ │ ├── CastToGfloat16Sr.h │ │ │ ├── CastToGfloat32.S │ │ │ ├── CastToGfloat32.h │ │ │ ├── CastToGfloat32Param.S │ │ │ ├── CastToGfloat32Param.h │ │ │ ├── CastToGfloat32Sr.S │ │ │ ├── CastToGfloat32Sr.h │ │ │ ├── GfloatConst.hpp │ │ │ ├── PackedGfloatParams.S │ │ │ ├── PackedGfloatParams.h │ │ │ └── popfloatCommon.inc │ │ ├── popfloatCodelets.hpp │ │ ├── popfloatCycleCount.hpp │ │ └── popfloatUtils.hpp │ ├── popfloatCycleEstimators.cpp │ └── popfloatCycleEstimators.hpp ├── popfloat_mock │ ├── CMakeLists.txt │ └── codelets.cpp ├── poplibs-config.cmake ├── poplibs_mock-config.cmake ├── poplibs_support │ ├── Algorithms.cpp │ ├── CMakeLists.txt │ ├── ContiguousRegionsByTile.cpp │ ├── IclUtil.cpp │ ├── PlanConstraints.cpp │ ├── StridedRegions.cpp │ ├── TestDevice.cpp │ ├── TraceChannels.cpp │ ├── codelets.cpp │ ├── forceInterleavedEstimates.cpp │ └── logging.cpp ├── poplibs_test │ ├── CMakeLists.txt │ ├── CTCInference.cpp │ ├── CTCLoss.cpp │ ├── CTCUtil.cpp │ ├── Convolution.cpp │ ├── Embedding.cpp │ ├── FullyConnected.cpp │ ├── GeneralMatrixAdd.cpp │ ├── GeneralMatrixMultiply.cpp │ ├── Gru.cpp │ ├── Lstm.cpp │ ├── Multirate.cpp │ ├── NonLinearity.cpp │ ├── Norms.cpp │ ├── Pass.cpp │ ├── Pooling.cpp │ ├── Rnn.cpp │ └── Util.cpp ├── poplin │ ├── CMakeLists.txt │ ├── CanonicalConvParams.hpp │ ├── Cholesky.cpp │ ├── ConvModel.cpp │ ├── ConvModel.hpp │ ├── ConvOptions.cpp │ ├── ConvOptions.hpp │ ├── ConvParams.cpp │ ├── ConvPartialsStridesPacking.cpp │ ├── ConvPartialsStridesPacking.hpp │ ├── ConvPlan.cpp │ ├── ConvPlan.hpp │ ├── ConvPlanTypes.hpp │ ├── ConvPreplan.cpp │ ├── ConvProgramTree.hpp │ ├── ConvReduce.cpp │ ├── ConvReduce.hpp │ ├── ConvReducePlan.cpp │ ├── ConvReducePlan.hpp │ ├── ConvTransforms.cpp │ ├── ConvTransforms.hpp │ ├── ConvUtil.cpp │ ├── ConvUtilInternal.cpp │ ├── ConvUtilInternal.hpp │ ├── ConvValidation.cpp │ ├── ConvValidation.hpp │ ├── ConvVertexType.cpp │ ├── ConvVertexType.hpp │ ├── ConvVertices.cpp │ ├── ConvVertices.hpp │ ├── Convolution.cpp │ ├── ConvolutionInternal.hpp │ ├── ExchangeEstimator.hpp │ ├── FullyConnected.cpp │ ├── LuFactorization.cpp │ ├── MatMul.cpp │ ├── MatMulInternal.hpp │ ├── MeshGrid.cpp │ ├── MultiConvolution.cpp │ ├── MultiConvolutionInternal.hpp │ ├── Norms.cpp │ ├── PerformanceEstimation.hpp │ ├── PlanningCache.hpp │ ├── PlanningObjective.hpp │ ├── QRFactorization.cpp │ ├── TriangularSolve.cpp │ ├── Winograd.cpp │ ├── Winograd.hpp │ ├── codelets.cpp │ ├── codelets │ │ ├── Cholesky.cpp │ │ ├── ConvPartial1x1Out.cpp │ │ ├── ConvPartial1xNSLIC.cpp │ │ ├── ConvPartialHorizontalMac.cpp │ │ ├── ConvPartialHorizontalMac1x1.cpp │ │ ├── ConvPartialVerticalMac.cpp │ │ ├── ConvPartialnx1.cpp │ │ ├── Dot.hpp │ │ ├── InverseStdDeviation.cpp │ │ ├── LuFactorization.cpp │ │ ├── OuterProduct.cpp │ │ ├── QRFactorization.cpp │ │ ├── ReduceAdd.cpp │ │ ├── TriangularSolve.cpp │ │ ├── WgdConvComplete.cpp │ │ ├── WgdDataTransform.cpp │ │ ├── WgdInverseTransform.cpp │ │ ├── WgdKernelTransform.cpp │ │ ├── WgdPartials.cpp │ │ ├── WgdReduce.cpp │ │ ├── asm │ │ │ ├── ConvPartial1x4SLIC_half_float_8_and_half_half_16.S │ │ │ ├── ConvPartial1x4SLIC_half_float_8_and_half_half_16_cgpg_gt4.S │ │ │ ├── ConvPartial1x4SLIC_half_half_8.S │ │ │ ├── OuterProduct.S │ │ │ ├── ReduceAdd.S │ │ │ ├── ReduceAddSingleInput.S │ │ │ ├── conv_hzmac1x1_half_float.S │ │ │ ├── conv_hzmac_common.h.S │ │ │ ├── conv_hzmac_float_float.S │ │ │ ├── conv_hzmac_float_float_non_limited.S │ │ │ ├── conv_hzmac_half_float.S │ │ │ ├── conv_hzmac_half_float_non_limited.S │ │ │ ├── conv_hzmac_half_half.S │ │ │ ├── conv_hzmac_half_half_non_limited.S │ │ │ ├── conv_partial_1x1_float_float.S │ │ │ ├── conv_partial_1x1_float_float_16.S │ │ │ ├── conv_partial_1x1_half_float_8_and_half_half_h16.S │ │ │ ├── conv_partial_1x1_half_half.S │ │ │ ├── conv_partial_1x1_supervisor.S │ │ │ ├── conv_partial_nx1_float_float.S │ │ │ ├── conv_partial_nx1_float_float_16.S │ │ │ ├── conv_partial_nx1_half_float_8_and_half_half_16.S │ │ │ ├── conv_partial_nx1_half_half.S │ │ │ ├── conv_partial_nx1_supervisor.S │ │ │ ├── conv_partial_nx1_zero_output.S │ │ │ ├── conv_partial_zero_output_stack.h │ │ │ ├── conv_sr_ctrl.h.S │ │ │ ├── conv_vmac_common.h.S │ │ │ ├── conv_vmac_half_float.S │ │ │ ├── conv_vmac_half_half.S │ │ │ ├── conv_vmac_half_half_16.S │ │ │ └── conv_vmac_half_half_8.S │ │ ├── convCastSupport.hpp │ │ ├── inlineAssemblerConv.hpp │ │ ├── inlineAssemblerSLIC.hpp │ │ └── inlineAssemblerSLICStride2.hpp │ ├── poplinCycleEstimators.cpp │ └── poplinCycleEstimators.hpp ├── poplin_mock │ ├── CMakeLists.txt │ ├── MatMul.cpp │ └── codelets.cpp ├── popnn │ ├── BatchNorm.cpp │ ├── CMakeLists.txt │ ├── CTCInference.cpp │ ├── CTCInferenceConnection.cpp │ ├── CTCInferenceConnection.hpp │ ├── CTCInferencePlan.cpp │ ├── CTCInferencePlan.hpp │ ├── CTCLoss.cpp │ ├── CTCLossPlan.cpp │ ├── CTCLossPlan.hpp │ ├── CTCPlanInternal.cpp │ ├── CTCPlanInternal.hpp │ ├── CreatePoolingVertex.hpp │ ├── GroupNorm.cpp │ ├── Gru.cpp │ ├── HardSigmoid.cpp │ ├── HardSigmoid.hpp │ ├── LogSoftmax.cpp │ ├── Loss.cpp │ ├── Lstm.cpp │ ├── NonLinearity.cpp │ ├── NonLinearityInternal.hpp │ ├── Norms.cpp │ ├── NormsInternal.cpp │ ├── NormsInternal.hpp │ ├── PerformanceEstimation.hpp │ ├── PoolOptions.hpp │ ├── PoolPlan.cpp │ ├── PoolPlan.hpp │ ├── PoolVertices.cpp │ ├── PoolVertices.hpp │ ├── Pooling.cpp │ ├── PoolingDefUtil.hpp │ ├── ROIAlign.cpp │ ├── Recurrent.cpp │ ├── Rnn.cpp │ ├── RnnUtil.hpp │ ├── SpatialSoftMax.cpp │ ├── codelets.cpp │ ├── codelets │ │ ├── CTCInference.cpp │ │ ├── CTCLoss.cpp │ │ ├── CalcAccuracy.cpp │ │ ├── LogOps.hpp │ │ ├── LossCrossEntropyTransform.cpp │ │ ├── LossSumSquaredTransform.cpp │ │ ├── MaxPooling.cpp │ │ ├── MaxPoolingGrad.cpp │ │ ├── MaxPoolingGradientScale.cpp │ │ ├── MinHeapView.hpp │ │ ├── NonLinearity.hpp │ │ ├── NonLinearity1D.cpp │ │ ├── NonLinearity2D.cpp │ │ ├── NonLinearityGrad1D.cpp │ │ ├── NonLinearityGrad2D.cpp │ │ ├── ROIAlign.cpp │ │ ├── ReduceMaxClassGather.cpp │ │ ├── ReduceMaxClassSparse.cpp │ │ ├── ReduceMaxNClassGather.cpp │ │ ├── ReduceMaxNClassSparse.cpp │ │ ├── ReduceMinClassGather.cpp │ │ ├── ReduceMinClassSparse.cpp │ │ ├── SelectiveScaling.cpp │ │ ├── SumPooling.cpp │ │ └── asm │ │ │ ├── CTCInferenceSort.S │ │ │ ├── CTCInferenceUpdate.S │ │ │ ├── LossTransform.S │ │ │ ├── NonLinearity1DSwish.S │ │ │ ├── NonLinearity1D_gelu.S │ │ │ ├── NonLinearity2DSwish.S │ │ │ ├── NonLinearity2D_gelu.S │ │ │ ├── NonLinearityGrad1D.S │ │ │ ├── NonLinearityGrad1DSwish.S │ │ │ ├── NonLinearityGrad1D_gelu.S │ │ │ ├── NonLinearityGrad2D.S │ │ │ ├── NonLinearityGrad2DSwish.S │ │ │ ├── NonLinearityGrad2D_gelu.S │ │ │ ├── NonLinearityGradLoop_gelu.S │ │ │ ├── NonLinearityLoop_gelu.S │ │ │ ├── NonLinearitySwishCommon.S │ │ │ ├── Pooling.S │ │ │ ├── ReduceClassGather.S │ │ │ └── ReduceClassSparse.S │ ├── popnnCycleEstimators.cpp │ └── popnnCycleEstimators.hpp ├── popnn_mock │ ├── CMakeLists.txt │ └── codelets.cpp ├── popops │ ├── AllTrue.cpp │ ├── BitonicTopK.cpp │ ├── BitonicTopK.hpp │ ├── CMakeLists.txt │ ├── Cast.cpp │ ├── CastModelling.cpp │ ├── CastModelling.hpp │ ├── CircBuf.cpp │ ├── DynamicSlice.cpp │ ├── DynamicSliceInternal.hpp │ ├── ElementWise.cpp │ ├── ElementWiseInternal.cpp │ ├── ElementWiseInternal.hpp │ ├── ElementWiseUtil.cpp │ ├── ElementWiseUtilInternal.hpp │ ├── Encoding.cpp │ ├── ExchangeEstimator.cpp │ ├── ExchangeEstimator.hpp │ ├── Expr.cpp │ ├── ExprOpUtil.cpp │ ├── ExprOpUtil.hpp │ ├── ExprOpUtils.cpp │ ├── ExpressionGenerator.cpp │ ├── ExpressionGenerator.hpp │ ├── Fill.cpp │ ├── FillModelling.cpp │ ├── FillModelling.hpp │ ├── Gather.cpp │ ├── GatherInternal.cpp │ ├── GatherInternal.hpp │ ├── GatherStatistics.cpp │ ├── HistogramPerformanceEstimation.cpp │ ├── HistogramPerformanceEstimation.hpp │ ├── HostSliceTensor.cpp │ ├── Loop.cpp │ ├── NaN.cpp │ ├── NormaliseImage.cpp │ ├── Operation.cpp │ ├── Pad.cpp │ ├── Padder.cpp │ ├── Padder.hpp │ ├── PerformanceEstimation.cpp │ ├── Rearrange.cpp │ ├── RearrangeUtil.cpp │ ├── RearrangeUtil.hpp │ ├── ScalarMultiply.cpp │ ├── ScalarMultiply.hpp │ ├── ScaledAdd.cpp │ ├── ScaledAddModelling.cpp │ ├── ScaledAddModelling.hpp │ ├── Scatter.cpp │ ├── SelectScalarFromRows.cpp │ ├── SequenceSlice.cpp │ ├── Sort.cpp │ ├── SortOrder.cpp │ ├── SparseUtils.cpp │ ├── SparseUtils.hpp │ ├── SplineBasis.cpp │ ├── SplineWeighting.cpp │ ├── TopK.cpp │ ├── UpdateScalarInRows.cpp │ ├── VarianceToOrFromInvStdDev.cpp │ ├── Zero.cpp │ ├── codelets.cpp │ ├── codelets │ │ ├── BroadcastVectorInner1D.cpp │ │ ├── BroadcastVectorInner1DInPlace.cpp │ │ ├── BroadcastVectorInner2D.cpp │ │ ├── BroadcastVectorInner2DInPlace.cpp │ │ ├── CheckAccuracyWhenCast.cpp │ │ ├── CheckAccuracyWhenCast.hpp │ │ ├── CircBufIncrIndex.cpp │ │ ├── CircOffset.cpp │ │ ├── CompareAndSwapAtDistance.cpp │ │ ├── ContinuousReduce.cpp │ │ ├── ContinuousReduce.hpp │ │ ├── DynamicSlice1D.cpp │ │ ├── DynamicSlice2D.cpp │ │ ├── DynamicUpdateSlice1D.cpp │ │ ├── DynamicUpdateSlice2D.cpp │ │ ├── EncodeOneHot.cpp │ │ ├── EncodeOneHotCustomValues.cpp │ │ ├── HasNaN.cpp │ │ ├── HeapSort.hpp │ │ ├── HeapSortVertex.cpp │ │ ├── HeapSortVertexKV.cpp │ │ ├── Iota.cpp │ │ ├── MultiSlice.cpp │ │ ├── MultiSliceUpdateCommon.cpp │ │ ├── MultiSliceUpdateCommon.hpp │ │ ├── MultiUpdate.cpp │ │ ├── MultiUpdateOp.cpp │ │ ├── MultiUpdateOp.hpp │ │ ├── NormaliseImage.cpp │ │ ├── Reduce.cpp │ │ ├── ReduceCodelets.hpp │ │ ├── ScalarMultiply.cpp │ │ ├── ScaledContinuousReduce.cpp │ │ ├── ScaledReduce.cpp │ │ ├── SelectFromInterval.cpp │ │ ├── SelectFromIntervals.cpp │ │ ├── SelectFromRowsInColumns.cpp │ │ ├── SelectScalarFromRows.hpp │ │ ├── SeqSlice.cpp │ │ ├── SplineBasis.cpp │ │ ├── SplineWeighting.cpp │ │ ├── UpdateColumnsDEC.cpp │ │ ├── UpdateIntervalDEC.cpp │ │ ├── UpdateIntervalsDEC.cpp │ │ ├── asm │ │ │ ├── BinarySearch.S │ │ │ ├── BinarySearch.h.S │ │ │ ├── BroadcastSelect.S │ │ │ ├── Clamp.S │ │ │ ├── CommonPoplibsMacros.h.S │ │ │ ├── CompareAndSwapAtDistanceKeyVal_float_unsigned.S │ │ │ ├── ContinuousReductionAcc.S │ │ │ ├── ContinuousReductionNoAcc.S │ │ │ ├── EncodeOneHot.S │ │ │ ├── Fill.S │ │ │ ├── ForLoopCounter.S │ │ │ ├── HasNaN.S │ │ │ ├── MathConstants.S │ │ │ ├── MultiSlice.S │ │ │ ├── MultiSliceUpdateCommon.h.S │ │ │ ├── MultiUpdateOp.S │ │ │ ├── NormaliseImage.S │ │ │ ├── ReductionSpecial01Acc.S │ │ │ ├── ReductionSpecial01NoAcc.S │ │ │ ├── ReductionSpecial2.S │ │ │ ├── ReductionSpecial3.S │ │ │ ├── ReductionsCommon.h.S │ │ │ ├── ScalarMultiply.S │ │ │ ├── ScaledAdd2DXminusaXPlusbY_half.S │ │ │ ├── ScaledAdd2D_float.S │ │ │ ├── ScaledAdd2D_float_half.S │ │ │ ├── ScaledAdd2D_half.S │ │ │ ├── ScaledAdd2D_half_float.S │ │ │ ├── ScaledAdd2D_integral.S │ │ │ ├── ScaledAddSupervisor.inc │ │ │ ├── ScaledAddSupervisor_float_half.S │ │ │ ├── ScaledAddSupervisor_fp.S │ │ │ ├── ScaledAdd_half_half_float.S │ │ │ ├── ScaledAddaXPlusbY_mixed.S │ │ │ ├── SliceCopyFunction.S │ │ │ ├── SliceCopyFunction_8bit.inc │ │ │ ├── VarianceConversion1D.S │ │ │ ├── VarianceConversion2D.S │ │ │ ├── binaryOps1D.S │ │ │ ├── binaryOps2D.S │ │ │ ├── dynamicSlice.S │ │ │ ├── dynamicSlice.inc │ │ │ ├── dynamicSlice1D.S │ │ │ ├── dynamicSlice1D_8bit.S │ │ │ ├── histogram1DByData.S │ │ │ ├── histogram1DByLimit.S │ │ │ ├── histogram2D.S │ │ │ ├── histogramCommon.S │ │ │ ├── select_bool.S │ │ │ ├── select_half.S │ │ │ ├── select_int_float.S │ │ │ ├── unary2DNonLinearity.S │ │ │ ├── unaryOps1D.S │ │ │ ├── unaryOps1DNonLinearity.S │ │ │ ├── unaryOps2D.S │ │ │ ├── unaryOpsOps.h.S │ │ │ ├── vectorInnerAdd_float.S │ │ │ ├── vectorInnerAdd_half.S │ │ │ ├── vectorInnerCommon.h.S │ │ │ ├── vectorInnerDiv_float.S │ │ │ ├── vectorInnerDiv_half.S │ │ │ ├── vectorInnerMul_float.S │ │ │ ├── vectorInnerMul_half.S │ │ │ ├── vectorOuterOps1D.S │ │ │ └── workDivision.h.S │ │ ├── broadcastCodelets.cpp │ │ ├── elementwiseCodelets.hpp │ │ ├── elemwiseBinaryCodelets.cpp │ │ ├── elemwiseBinaryOps.hpp │ │ ├── elemwiseMiscCodelets.cpp │ │ ├── elemwiseScaledAddCodelets.cpp │ │ ├── elemwiseUnaryCodelets.cpp │ │ ├── inlineAssembler.hpp │ │ ├── inlineAssemblerCast.hpp │ │ ├── inlineAssemblerUnaryOps.hpp │ │ └── util.hpp │ ├── popopsCycleEstimators.cpp │ ├── popopsCycleEstimators.hpp │ └── reduction │ │ ├── ComputeSetList.cpp │ │ ├── ComputeSetList.hpp │ │ ├── CycleEstimationFunctions.cpp │ │ ├── CycleEstimationFunctions.hpp │ │ ├── IntermediatePartials.cpp │ │ ├── IntermediatePartials.hpp │ │ ├── IntermediatePartialsUtil.cpp │ │ ├── IntermediatePartialsUtil.hpp │ │ ├── Modelling.cpp │ │ ├── Modelling.hpp │ │ ├── Reduction.cpp │ │ ├── ReductionConnection.cpp │ │ ├── ReductionConnection.hpp │ │ ├── ReductionIntrospection.cpp │ │ ├── ReductionIntrospection.hpp │ │ ├── ReductionPlan.cpp │ │ ├── ReductionPlan.hpp │ │ ├── ReductionStages.cpp │ │ ├── ReductionStages.hpp │ │ ├── ReductionVertex.hpp │ │ ├── ReductionVertexDefs.hpp │ │ ├── RegionWrapping.cpp │ │ └── RegionWrapping.hpp ├── popops_mock │ ├── CMakeLists.txt │ ├── ElementWise.cpp │ ├── ElementWiseUtil.cpp │ └── codelets.cpp ├── poprand │ ├── CMakeLists.txt │ ├── RandomGen.cpp │ ├── codelets.cpp │ ├── codelets │ │ ├── Bernoulli.cpp │ │ ├── Dropout.cpp │ │ ├── Normal.cpp │ │ ├── RandomUtils.hpp │ │ ├── SetSeed.cpp │ │ ├── TruncatedNormal.cpp │ │ ├── Uniform.cpp │ │ └── asm │ │ │ ├── Bernoulli.S │ │ │ ├── Dropout.S │ │ │ ├── Normal.S │ │ │ ├── Seeds.S │ │ │ ├── TruncatedNormal.S │ │ │ ├── Uniform.S │ │ │ └── poprandCommon.inc │ ├── poprandCycleEstimators.cpp │ └── poprandCycleEstimators.hpp ├── poprand_mock │ ├── CMakeLists.txt │ └── codelets.cpp ├── popsparse │ ├── BSMatrix.cpp │ ├── BSMatrix.hpp │ ├── BSNonLinearity.cpp │ ├── BSNonLinearity.hpp │ ├── BSOps.cpp │ ├── BSOps.hpp │ ├── BSUtils.cpp │ ├── BSUtils.hpp │ ├── BalancedPartitioner.cpp │ ├── BalancedPartitioner.hpp │ ├── BlockSparseMatMul.cpp │ ├── CMakeLists.txt │ ├── Embedding.cpp │ ├── FullyConnected.cpp │ ├── FullyConnectedOnTile.cpp │ ├── FullyConnectedOnTile.hpp │ ├── FullyConnectedOptions.cpp │ ├── FullyConnectedOptions.hpp │ ├── FullyConnectedPNMapping.cpp │ ├── FullyConnectedPNMapping.hpp │ ├── FullyConnectedParams.cpp │ ├── FullyConnectedPlan.cpp │ ├── FullyConnectedPlan.hpp │ ├── FullyConnectedTensorMetaData.hpp │ ├── FullyConnectedUtils.cpp │ ├── FullyConnectedUtils.hpp │ ├── FullyConnectedVector.hpp │ ├── HyperGraph.cpp │ ├── HyperGraph.hpp │ ├── HyperGraphBlock.cpp │ ├── HyperGraphBlock.hpp │ ├── HyperGraphBlockGroup.cpp │ ├── HyperGraphBlockGroup.hpp │ ├── HyperGraphBlockGroup2.cpp │ ├── HyperGraphBlockGroup2.hpp │ ├── HyperGraphBlockNaive.cpp │ ├── HyperGraphBlockNaive.hpp │ ├── HyperGraphBlockZoltan.cpp │ ├── HyperGraphBlockZoltan.hpp │ ├── HyperGraphPartitioner.cpp │ ├── HyperGraphPartitioner.hpp │ ├── HyperGraphStrip.cpp │ ├── HyperGraphStrip.hpp │ ├── HyperGraphStripV0.cpp │ ├── HyperGraphStripV0.hpp │ ├── MatMul.cpp │ ├── MatMulOptions.cpp │ ├── MatMulOptions.hpp │ ├── MatMulParams.cpp │ ├── MatMulTensorMetaData.hpp │ ├── MatMulUtils.cpp │ ├── MatMulUtils.hpp │ ├── PerformanceEstimation.hpp │ ├── PlanningCache.cpp │ ├── PlanningCacheImpl.hpp │ ├── SparseCodeletMetaInfoScale.hpp │ ├── SparseFormatsValidate.cpp │ ├── SparseFormatsValidate.hpp │ ├── SparseMetaInfo.hpp │ ├── SparsePartitioner.cpp │ ├── SparsePartitionerImpl.cpp │ ├── SparsePartitionerImpl.hpp │ ├── SparsePartitionerOptions.cpp │ ├── SparsePartitionerOptions.hpp │ ├── SparseStorageInternal.hpp │ ├── SparseTensor.cpp │ ├── SparsityParams.cpp │ ├── StaticMatMul.cpp │ ├── StaticMatMulPartitioner.cpp │ ├── StaticMatMulPartitioner.hpp │ ├── ZoltanPartitioner.cpp │ ├── ZoltanPartitioner.hpp │ ├── codelets.cpp │ ├── codelets │ │ ├── BlockTransposeGradW.cpp │ │ ├── SparseDenseMatMulBlock.cpp │ │ ├── SparseDenseMatMulBlockAmpGradW.cpp │ │ ├── SparseDenseMatMulBlockGradA.cpp │ │ ├── SparseDenseMatMulBlockGradW.cpp │ │ ├── SparseDenseMatMulElementWise.cpp │ │ ├── SparseDenseMatMulElementWiseTranspose.cpp │ │ ├── SparseDenseMatMulGradAElementWise.cpp │ │ ├── SparseDenseMatMulGradWElementWise.cpp │ │ ├── SparseDenseMultiSliceBlock.cpp │ │ ├── SparseDenseMultiSliceElementWise.cpp │ │ ├── SparseGather.cpp │ │ ├── StaticSparseDenseElementWise.cpp │ │ ├── StaticSparseDenseMatMulBlock.cpp │ │ ├── Utils.cpp │ │ └── asm │ │ │ ├── Block16x16SparseDenseMatMulAmpGradW_half_float.S │ │ │ ├── Block16x16SparseDenseMatMulAmpGradW_half_half.S │ │ │ ├── Block16x16SparseDenseMatMulAmpGradW_half_half_2ampsets.S │ │ │ ├── Block16x16SparseDenseMatMulGradA_half_float.S │ │ │ ├── Block16x16SparseDenseMatMulGradA_half_half.S │ │ │ ├── Block16x16SparseDenseMatMulGradA_half_half_2ampsets.S │ │ │ ├── Block16x16SparseDenseMatMulGradW_half_float.S │ │ │ ├── Block16x16SparseDenseMatMulGradW_half_half.S │ │ │ ├── Block16x16SparseDenseMatMul_half_float.S │ │ │ ├── Block16x16SparseDenseMatMul_half_half.S │ │ │ ├── Block16x16SparseDenseMatMul_half_half_2ampsets.S │ │ │ ├── Block4x4SparseDenseMatMulAmpGradW_float_float.S │ │ │ ├── Block4x4SparseDenseMatMulAmpGradW_half_float.S │ │ │ ├── Block4x4SparseDenseMatMulAmpGradW_half_half.S │ │ │ ├── Block4x4SparseDenseMatMulGradA_float_float.S │ │ │ ├── Block4x4SparseDenseMatMulGradA_half_float.S │ │ │ ├── Block4x4SparseDenseMatMulGradA_half_half.S │ │ │ ├── Block4x4SparseDenseMatMulGradW_float_float.S │ │ │ ├── Block4x4SparseDenseMatMulGradW_half_float.S │ │ │ ├── Block4x4SparseDenseMatMulGradW_half_half.S │ │ │ ├── Block4x4SparseDenseMatMul_float_float.S │ │ │ ├── Block4x4SparseDenseMatMul_half_float.S │ │ │ ├── Block4x4SparseDenseMatMul_half_half.S │ │ │ ├── Block8x8SparseDenseMatMulAmpGradW_float_float.S │ │ │ ├── Block8x8SparseDenseMatMulAmpGradW_half_float.S │ │ │ ├── Block8x8SparseDenseMatMulAmpGradW_half_half.S │ │ │ ├── Block8x8SparseDenseMatMulGradA_float_float.S │ │ │ ├── Block8x8SparseDenseMatMulGradA_half_float.S │ │ │ ├── Block8x8SparseDenseMatMulGradA_half_half.S │ │ │ ├── Block8x8SparseDenseMatMulGradW_float_float.S │ │ │ ├── Block8x8SparseDenseMatMulGradW_half_float.S │ │ │ ├── Block8x8SparseDenseMatMulGradW_half_half.S │ │ │ ├── Block8x8SparseDenseMatMul_float_float.S │ │ │ ├── Block8x8SparseDenseMatMul_half_float.S │ │ │ ├── Block8x8SparseDenseMatMul_half_half.S │ │ │ ├── BlockMatMulGradWCommon.S │ │ │ ├── BlockSparseDenseMatMul.h.S │ │ │ ├── BlockSparseMatMulAmpGradW.h.S │ │ │ ├── BlockSparseMatMulGradW.h.S │ │ │ ├── BlockSparseMatMulStructs.h.S │ │ │ ├── BlockTransposeGradW.h.S │ │ │ ├── BlockTransposeGradW_float.S │ │ │ ├── BlockTransposeGradW_half.S │ │ │ ├── SparseDenseMatMulElementWise.h.S │ │ │ ├── SparseDenseMatMulElementWise_float_float.S │ │ │ ├── SparseDenseMatMulElementWise_half_float.S │ │ │ ├── SparseDenseMatMulGradAElementWise.h.S │ │ │ ├── SparseDenseMatMulGradAElementWise_float_float.S │ │ │ ├── SparseDenseMatMulGradAElementWise_half_float.S │ │ │ ├── SparseDenseMatMulGradWElementWise.h.S │ │ │ ├── SparseDenseMatMulGradWElementWise_float_float.S │ │ │ ├── SparseDenseMatMulGradWElementWise_half_float.S │ │ │ ├── SparseDenseMatMulStructs.h.S │ │ │ ├── SparseDenseMatMulTranspElementWise.h.S │ │ │ ├── SparseDenseMatMulTranspElementWise_float_float.S │ │ │ ├── SparseDenseMatMulTranspElementWise_half_float.S │ │ │ ├── SparseDenseMultiSliceBlock.S │ │ │ ├── SparseDenseMultiSliceElementWise.S │ │ │ ├── SparseDenseMultiUpdateAddBlock.S │ │ │ ├── SparseDenseMultiUpdateAddElementWise.S │ │ │ ├── SparseGatherElementWise.S │ │ │ ├── StaticBlock16x16SparseDenseMatMul_half_half.S │ │ │ ├── StaticBlock16x8SparseDenseMatMul_float_float.S │ │ │ ├── StaticBlock4x4SparseDenseMatMul_float_float.S │ │ │ ├── StaticBlock4x4SparseDenseMatMul_half_half.S │ │ │ ├── StaticBlock8x8SparseDenseMatMul_float_float.S │ │ │ ├── StaticBlock8x8SparseDenseMatMul_half_half.S │ │ │ ├── StaticBlockSparseDenseMatMul.h.S │ │ │ ├── StaticSparseDenseElementWise_float_float.S │ │ │ └── StaticSparseDenseElementWise_half_half.S │ ├── popsparseCycleEstimators.cpp │ └── popsparseCycleEstimators.hpp ├── poputil │ ├── Broadcast.cpp │ ├── CMakeLists.txt │ ├── DebugInfo.cpp │ ├── GraphFunction.cpp │ ├── TensorMetaData.cpp │ ├── TensorMetaDataBase.hpp │ ├── TensorUseTracker.cpp │ ├── TileMapping.cpp │ ├── Util.cpp │ ├── VarStructure.cpp │ └── exceptions.cpp └── poputil_mock │ ├── CMakeLists.txt │ └── TileMapping.cpp ├── lsan.supp ├── packaging_files └── enable.sh.in ├── requirements.txt ├── tests ├── CMakeLists.txt ├── popfloat │ ├── CMakeLists.txt │ └── DebugInfoTest.cpp ├── poplibs_support │ ├── CMakeLists.txt │ ├── LoggingTest.cpp │ ├── MultiArrayTest.cpp │ ├── PlanConstraintsTest.cpp │ └── StridedRegionsTest.cpp ├── poplibs_test │ ├── CMakeLists.txt │ └── IdenticalLayoutTest.cpp ├── poplin │ ├── CMakeLists.txt │ ├── CholeskyTest.cpp │ ├── ConvExpandDimsVertexTest.cpp │ ├── ConvOptionsTest.cpp │ ├── ConvPlanTest.cpp │ ├── ConvTest.cpp │ ├── ConvUtilTest.cpp │ ├── LuFactorizationTest.cpp │ ├── MeshGridTest.cpp │ ├── MultiConvolutionPlanTest.cpp │ ├── MultiConvolutionTest.cpp │ ├── QRFactorizationTest.cpp │ ├── RangeTest.cpp │ ├── TriangularSolveTest.cpp │ ├── WinogradConv.cpp │ ├── codelets │ │ ├── CMakeLists.txt │ │ ├── ConvPartial1x1Out.cpp │ │ ├── ConvPartial1xNSLIC.cpp │ │ └── OuterProductTest.cpp │ ├── json │ │ ├── depthwise_conv_half.json │ │ ├── depthwise_conv_quarter1.json │ │ ├── depthwise_conv_quarter2.json │ │ ├── method_amp.json │ │ ├── pc_T10392.json │ │ ├── pc_conv7x7_stride_2_1024_in_512_out_serial_fail_case.json │ │ ├── pc_serial_split_ocx2.json │ │ ├── pc_serial_split_ocx3.json │ │ ├── pc_serial_split_ocx4.json │ │ ├── pointwise_conv_float.json │ │ ├── pointwise_reusable_conv_float.json │ │ ├── simple_depthwise_conv.json │ │ ├── slic144.json │ │ ├── slic1611.json │ │ ├── slic222.json │ │ ├── slic411.json │ │ └── slic811.json │ └── vertexVerifier │ │ ├── CMakeLists.txt │ │ ├── ConvPartialHalfHalfnx1KernelShapes.vv │ │ ├── ConvPartialQuarterHalf1x1Out.vv │ │ ├── ConvPartialQuarterHalf1x1OutConvGroups.vv │ │ ├── ConvPartialQuarterHalf1xnStride1.vv │ │ ├── ConvPartialQuarterHalf1xnStride2.vv │ │ ├── ConvPartialQuarterHalfnx1.vv │ │ ├── ConvPartialQuarterHalfnx1ConvGroups.vv │ │ └── ConvPartialQuarterHalfnx1KernelShapes.vv ├── popnn │ ├── BigNLVertices.cpp │ ├── CMakeLists.txt │ ├── CTCLossPlanTest.cpp │ ├── GraphProgLocationTest.cpp │ ├── LogSoftmaxTest.cpp │ ├── LossTest.cpp │ ├── NonLinearityGradSweepTest.cpp │ ├── NonLinearitySweepTest.cpp │ ├── NonLinearityTest.cpp │ ├── NormStatisticsTest.cpp │ ├── ROIAlignTest.cpp │ ├── SpatialSoftmaxTest.cpp │ └── codelets │ │ ├── CMakeLists.txt │ │ ├── CTCInferenceCodeletTest.cpp │ │ ├── CTCInferenceCodeletTestConnection.cpp │ │ ├── CTCInferenceCodeletTestConnection.hpp │ │ ├── CTCInferenceGenerateCandidates.cpp │ │ ├── CTCInferenceGenerateOutput.cpp │ │ ├── CTCInferenceMergeCandidates.cpp │ │ ├── CTCInferenceRankAndReduceCandidates.cpp │ │ ├── CTCInferenceUpdate.cpp │ │ ├── CTCLossCodeletTest.cpp │ │ ├── LossTransform.cpp.in │ │ ├── NonLinearity1D.cpp │ │ ├── NonLinearity2D.cpp │ │ └── PoolingCodeletTest.cpp ├── popops │ ├── AllTrueTest.cpp │ ├── BertSlicing.cpp │ ├── BertSlicingRefSmall.hpp │ ├── BinaryOpTest.cpp │ ├── BroadcastGeneratePatterns.cpp │ ├── BroadcastOptimiseTest.cpp │ ├── CMakeLists.txt │ ├── CircBufTests.cpp │ ├── DynamicSliceCreation.cpp │ ├── DynamicSliceTest.cpp │ ├── ElementWiseUtilTest.cpp │ ├── EncodingTest.cpp │ ├── ExprAPI.cpp │ ├── ExprName.cpp │ ├── GatherSimpleTest.cpp │ ├── GatherTest.cpp │ ├── HistogramTest.cpp │ ├── HostSliceTensorTest.cpp │ ├── LoopTest.cpp │ ├── MapExprMultiVertex.cpp │ ├── MapExprOptimisations.cpp │ ├── MapExprRemAndDivideOptimisations.cpp │ ├── MapExprScalar.cpp │ ├── MapFusionTest.cpp │ ├── MapMultipleOuts.cpp │ ├── MapWithOutputTest.cpp │ ├── NaNTest.cpp │ ├── NormaliseImageTest.cpp │ ├── PaddingTest.cpp │ ├── PlanMultipleCorrectnessTest.cpp │ ├── PlannedMultiSliceUpdateTest.cpp │ ├── QuarterTypeArithmeticTests.cpp │ ├── ReduceEdgeCases.cpp │ ├── ReductionPatternsTest.cpp │ ├── ReductionTests.cpp │ ├── RegroupTest.cpp │ ├── ScalarInFromRowsCommon.hpp │ ├── ScaledAddTest.cpp │ ├── ScatterTest.cpp │ ├── ScatterUpdateTest.cpp │ ├── SelectScalarFromRowsTest.cpp │ ├── SeqSliceTest.cpp │ ├── SortTest.cpp │ ├── SplineBasisTest.cpp │ ├── SplineWeightingTest.cpp │ ├── StdArithmeticTests.cpp │ ├── StdOperatorsTest.cpp │ ├── UnaryOpTest.cpp │ ├── UpdateScalarInRowsTest.cpp │ ├── codelets │ │ ├── BinaryCodeletsTest.cpp │ │ ├── BinaryCodeletsTest.hpp │ │ ├── BinaryOpRptLoopTest.vv │ │ ├── BroadcastSelect.cpp.in │ │ ├── CMakeLists.txt │ │ ├── CastCodeletsTest.cpp │ │ ├── CastTest.cpp │ │ ├── ClampTest.cpp.in │ │ ├── CodeletsTestsCommon.hpp │ │ ├── ContinuousReduce.cpp │ │ ├── DynamicSlice1DCodeletTest.cpp │ │ ├── DynamicSliceCodeletTest.cpp │ │ ├── FillCodeletsTest.cpp │ │ ├── FloatPointBehaviour.cpp │ │ ├── MultiSliceCodeletTest.cpp │ │ ├── PartialsEqualSizeReduce.cpp │ │ ├── Reduce.cpp │ │ ├── ReduceAdd.cpp │ │ ├── ReduceMaxClassGather.cpp │ │ ├── ReduceMaxClassSparse.cpp │ │ ├── ReduceNMaxClassGather.cpp │ │ ├── ReduceNMaxClassSparse.cpp │ │ ├── ReduceSpecial23.cpp │ │ ├── ScalarMultiplyCodeletsTest.cpp │ │ ├── ScaledAddCodeletsTest.cpp │ │ ├── Select.cpp.in │ │ ├── UnaryCodeletsTest.cpp │ │ ├── UnaryCodeletsTest.hpp │ │ ├── histogramCodeletTest.cpp │ │ └── select │ │ │ ├── bool.hpp │ │ │ ├── float.hpp │ │ │ ├── half.hpp │ │ │ ├── int.hpp │ │ │ └── unsigned_int.hpp │ └── infiles │ │ └── reduceInT59445.tensor ├── poprand │ └── CMakeLists.txt ├── popsparse │ ├── BlockSparseOpsTest.cpp │ ├── BlockSparseTest.cpp │ ├── CMakeLists.txt │ ├── PopsparseFullyConnectedPlan.cpp │ ├── ShardedSparseMatMul.cpp │ ├── SparseFormatsTest.cpp │ ├── SparseFormatsValidateTest.cpp │ ├── SparsePartitionerTests.cpp │ ├── StaticSparsePartitionerTest.cpp │ ├── bs-m8x8_0.8_nr.txt │ ├── codelets │ │ ├── BlockTransposeGradWTest.cpp │ │ ├── CMakeLists.txt │ │ ├── SparseDenseMatMulBlock.cpp │ │ ├── SparseDenseMatMulElementWise.cpp │ │ ├── SparseDenseMultiSlice.cpp │ │ ├── SparseDensePartitionBlock.cpp │ │ ├── SparseDensePartitionBlock.hpp │ │ ├── SparseDensePartitionElementWise.cpp │ │ ├── SparseDensePartitionElementWise.hpp │ │ ├── SparseDenseUtils.cpp │ │ ├── SparseDenseUtils.hpp │ │ └── SparseGatherTest.cpp │ └── static_sparse_T71209_mask.txt ├── poputil │ ├── BroadcastToMatchTest.cpp │ ├── CMakeLists.txt │ ├── CopyToIpu.cpp │ ├── DuplicateTensor.cpp │ ├── GraphFunctionTest.cpp │ ├── GraphReplication.cpp │ ├── LargeSplitRegionsTest.cpp │ ├── OptionParsingTest.cpp │ ├── TileMappingTest.cpp │ ├── UtilTest.cpp │ └── VarStructureTest.cpp ├── sanity │ ├── ApiCppVersionTest.cpp │ ├── CMakeLists.txt │ ├── ConsistentExecutableTest.cpp │ ├── EnumerateDevices.cpp │ ├── HangTest.cpp │ ├── ParallelTest.cpp │ └── dependencies │ │ ├── CMakeLists.txt │ │ └── check_cmake_link_include.py ├── soak-hw.json └── soak.json └── tools ├── CMakeLists.txt ├── bs_matmul_test.cpp ├── cast_to_gfloat.cpp ├── cast_to_gfloat.hpp ├── cast_to_gfloat_sr.cpp ├── consistent_executable_tool.cpp ├── ctc_beam_search.cpp ├── ctc_inference_model_validate.py ├── ctc_loss.cpp ├── ctc_model_validate.cpp ├── embedding_layer.cpp ├── fully_connected_layer.cpp ├── general_matrix_multiply.cpp ├── generate_cycle_estimate.py ├── gru_layer.cpp ├── lstm_layer.cpp ├── matrix_solver.cpp ├── multi_conv_layer.cpp ├── norm_layer.cpp ├── oct_conv_layer.cpp ├── pooling_layer.cpp ├── random_generator.cpp ├── reduce_op.cpp ├── rnn_layer.cpp ├── single_conv_layer.cpp ├── single_conv_layer_random.py ├── single_conv_soak.py ├── sparse_embedding_tied_matmul.cpp ├── sparse_fc_layer.cpp ├── sparse_matmul.cpp ├── src ├── conv_analysis.cpp └── conv_analysis.hpp ├── stalls_highlighter.py ├── static_sparse_matmul.cpp ├── test_determinism.py ├── topk.cpp └── transforms.py /.ci/view_component_trigger/Jenkinsfile: -------------------------------------------------------------------------------- 1 | @Library('sw-jenkins-library@view-component-trigger') _ 2 | 3 | viewComponentTrigger(jobsFilepath: '.ci/view_component_trigger/jobs.groovy') 4 | -------------------------------------------------------------------------------- /.ci/view_component_trigger/jobs.groovy: -------------------------------------------------------------------------------- 1 | [ 2 | [job: '/poplar/poplar_pr', parameters: [string(name: 'GCCI_BRANCH', value: 'mk2-main')]], 3 | ] 4 | -------------------------------------------------------------------------------- /.clang-format: -------------------------------------------------------------------------------- 1 | BasedOnStyle: llvm 2 | Language: Cpp 3 | -------------------------------------------------------------------------------- /.github/CODEOWNERS: -------------------------------------------------------------------------------- 1 | * @Software-GCAI/poplar 2 | -------------------------------------------------------------------------------- /.github/workflows/pre-commit.yaml: -------------------------------------------------------------------------------- 1 | name: pre-commit 2 | 3 | on: 4 | pull_request: 5 | 6 | concurrency: 7 | group: ${{ github.workflow }}-${{ github.ref }} 8 | cancel-in-progress: true 9 | 10 | jobs: 11 | pre-commit: 12 | runs-on: ["self-hosted", "linux"] 13 | steps: 14 | - uses: actions/checkout@v3 15 | with: 16 | fetch-depth: 0 # Required for us to have a valid ref to the target branch 17 | - uses: actions/setup-python@v3 18 | - uses: actions/cache@v3 19 | with: 20 | path: ~/.cache/pre-commit/ 21 | key: pre-commit-4|${{ env.pythonLocation }}|${{ hashFiles('.pre-commit-config.yaml') }} 22 | - uses: webfactory/ssh-agent@v0.8.0 23 | with: 24 | ssh-private-key: ${{ secrets.PRE_COMMIT_SCRIPTS_DEPLOY_KEY }} 25 | - name: SSH Keys and known_hosts 26 | run: | 27 | mkdir -p ~/.ssh/ && touch ~/.ssh/known_hosts 28 | ssh-keyscan github.com >> ~/.ssh/known_hosts 29 | - uses: pre-commit/action@v3.0.0 30 | with: 31 | extra_args: "--from-ref ${{ github.event.pull_request.base.sha }} --to-ref ${{ github.event.pull_request.head.sha }}" 32 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .idea/ 2 | tools/__pycache__ 3 | build/ 4 | CMakeLists.txt.user 5 | *.DS_Store 6 | cmake-build-debug 7 | 8 | .vscode 9 | compile_commands.json 10 | -------------------------------------------------------------------------------- /.pre-commit-config.yaml: -------------------------------------------------------------------------------- 1 | # See https://pre-commit.com for more information 2 | # See https://pre-commit.com/hooks.html for more hooks 3 | repos: 4 | - repo: https://github.com/pre-commit/pre-commit-hooks 5 | rev: v3.2.0 6 | hooks: 7 | - id: trailing-whitespace 8 | - id: end-of-file-fixer 9 | - id: check-json 10 | - id: check-added-large-files 11 | - repo: https://github.com/cheshirekow/cmake-format-precommit 12 | rev: v0.6.10 13 | hooks: 14 | - id: cmake-lint 15 | additional_dependencies: [pyyaml] 16 | args: [--config=.cmake-lint.yaml] 17 | types: [cmake] 18 | - repo: ssh://git@github.com/Software-GCAI/precommit-scripts 19 | rev: v1.0.1 20 | hooks: 21 | - id: gc-copyright 22 | -------------------------------------------------------------------------------- /License.txt: -------------------------------------------------------------------------------- 1 | Copyright (c) 2020 Graphcore Limited 2 | 3 | Licensed under terms of MIT license. 4 | You may obtain a copy of the license at https://opensource.org/licenses/MIT 5 | 6 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 7 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 8 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 9 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 10 | WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 11 | CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 12 | -------------------------------------------------------------------------------- /cbt.json: -------------------------------------------------------------------------------- 1 | { 2 | "dependencies" : [ 3 | "boost", 4 | "libpva", 5 | "libpvti", 6 | "gccs", 7 | "poplar", 8 | "spdlog", 9 | "tbb", 10 | "zoltan" 11 | ], 12 | "optional_dependencies": [ 13 | "googletest" 14 | ] 15 | } 16 | -------------------------------------------------------------------------------- /cmake/Modules/Findzoltan.cmake: -------------------------------------------------------------------------------- 1 | # Search for zoltan include directory and libraries 2 | # This module defines the following variables: 3 | # - ZOLTAN_INCLUDE_DIR 4 | # - ZOLTAN_LIBRARY 5 | # - ZOLTAN_SIMPI_LIBRARY 6 | 7 | find_path(ZOLTAN_INCLUDE_DIR zoltan.h 8 | HINTS ${ZOLTAN_ROOT}/include $ENV{ZOLTAN_ROOT}/include) 9 | 10 | find_library(ZOLTAN_LIBRARY zoltan 11 | HINTS ${ZOLTAN_ROOT}/lib $ENV{ZOLTAN_ROOT}/lib) 12 | 13 | find_library(ZOLTAN_SIMPI_LIBRARY simpi 14 | HINTS ${ZOLTAN_ROOT}/lib $ENV{ZOLTAN_ROOT}/lib) 15 | 16 | set(ZOLTAN_LIBRARIES ${ZOLTAN_LIBRARY} ${ZOLTAN_SIMPI_LIBRARY}) 17 | 18 | if(ZOLTAN_INCLUDE_DIR AND ZOLTAN_LIBRARY AND ZOLTAN_SIMPI_LIBRARY) 19 | if(NOT TARGET ZOLTAN::zoltan) 20 | add_library(ZOLTAN::zoltan STATIC IMPORTED) 21 | set_target_properties(ZOLTAN::zoltan PROPERTIES 22 | INTERFACE_INCLUDE_DIRECTORIES "${ZOLTAN_INCLUDE_DIR}" 23 | IMPORTED_LINK_INTERFACE_LANGUAGES "CXX" 24 | IMPORTED_LOCATION "${ZOLTAN_LIBRARY}") 25 | add_library(ZOLTAN::simpi STATIC IMPORTED) 26 | set_target_properties(ZOLTAN::simpi PROPERTIES 27 | INTERFACE_INCLUDE_DIRECTORIES "${ZOLTAN_INCLUDE_DIR}" 28 | IMPORTED_LINK_INTERFACE_LANGUAGES "CXX" 29 | IMPORTED_LOCATION "${ZOLTAN_SIMPI_LIBRARY}") 30 | endif() 31 | endif() 32 | 33 | include(FindPackageHandleStandardArgs) 34 | # Sets zoltan_FOUND 35 | find_package_handle_standard_args(zoltan DEFAULT_MSG 36 | ZOLTAN_INCLUDE_DIR ZOLTAN_LIBRARY ZOLTAN_SIMPI_LIBRARY) 37 | -------------------------------------------------------------------------------- /exported_symbols_linux.lds: -------------------------------------------------------------------------------- 1 | V0 { 2 | global: 3 | _ZN?pop*; 4 | _ZN??pop*; 5 | _ZNK?pop*; 6 | _ZNK??pop*; 7 | _ZTSN?pop*; 8 | _ZTSN??pop*; 9 | _ZTIN?pop*; 10 | _ZTIN??pop*; 11 | _ZTVN?pop*; 12 | _ZTVN??pop*; 13 | _ZStrs*6poplar4TypeE; 14 | _ZN?experimental*; 15 | _ZN??experimental*; 16 | local: 17 | *; 18 | }; 19 | -------------------------------------------------------------------------------- /exported_symbols_osx.lds: -------------------------------------------------------------------------------- 1 | __ZN?pop* 2 | __ZN??pop* 3 | __ZNK?pop* 4 | __ZNK??pop* 5 | __ZTSN?pop* 6 | __ZTSN??pop* 7 | __ZTIN?pop* 8 | __ZTIN??pop* 9 | __ZTVN?pop* 10 | __ZTVN??pop* 11 | __ZStrs*6poplar4TypeE 12 | __ZN?experimental* 13 | __ZN??experimental* 14 | -------------------------------------------------------------------------------- /include/popfloat/experimental/CastToHalf.hpp: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2019 Graphcore Ltd. All rights reserved. 2 | 3 | #ifndef POPFLOAT_HALF_UTILS_H 4 | #define POPFLOAT_HALF_UTILS_H 5 | 6 | namespace popfloat { 7 | namespace experimental { 8 | 9 | /** Cast a single precision input to half precision 10 | * 11 | * \param value Single precision input 12 | * \param enNanoo Enable Nan on overflow 13 | * \return The 16-bit representation of the half precision output 14 | */ 15 | uint16_t singleToHalf(float value, bool enNanoo = false); 16 | 17 | /** Cast a half precision input to single precision 18 | * 19 | * \param ihalf The 16-bit representation of the half precision input 20 | * \return Single precision output 21 | */ 22 | float halfToSingle(uint16_t ihalf); 23 | 24 | } // end namespace experimental 25 | } // end namespace popfloat 26 | 27 | #endif 28 | -------------------------------------------------------------------------------- /include/popfloat/experimental/codelets.hpp: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2019 Graphcore Ltd. All rights reserved. 2 | 3 | #ifndef popfloat_codelets_hpp 4 | #define popfloat_codelets_hpp 5 | #include 6 | 7 | namespace popfloat { 8 | namespace experimental { 9 | void addCodelets(poplar::Graph &graph); 10 | } // end namespace experimental 11 | } // end namespace popfloat 12 | 13 | #endif // popfloat_codelets_hpp 14 | -------------------------------------------------------------------------------- /include/popfloat_mock/Mock.hpp: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2022 Graphcore Ltd. All rights reserved. 2 | #ifndef popfloat_Mock_hpp 3 | #define popfloat_Mock_hpp 4 | 5 | #include 6 | #include 7 | 8 | namespace popfloat_mock { 9 | 10 | class MockPopfloat { 11 | public: 12 | // experimental/codelets.hpp 13 | 14 | MOCK_METHOD(void, experimental_addCodelets, (::poplar::Graph &)); 15 | }; 16 | 17 | extern MockPopfloat *mockPopfloat_; 18 | 19 | } // namespace popfloat_mock 20 | 21 | #endif // popfloat_Mock_hpp 22 | -------------------------------------------------------------------------------- /include/popfloat_mock/MockFixture.hpp: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2022 Graphcore Ltd. All rights reserved. 2 | #ifndef popfloat_Mock_Fixture_hpp 3 | #define popfloat_Mock_Fixture_hpp 4 | 5 | #include 6 | 7 | namespace popfloat_mock { 8 | 9 | template