IComputeBackend.h

Go to the documentation of this file.

#pragma once
#include <cstddef>
#include <deepity/backend/DeviceType.h>
#include <deepity/utils/Activations.h>
 
namespace Deep
{

class IComputeBackend
{
public:
  virtual ~IComputeBackend() = default;
 
  // Graphs

  virtual void BeginGraphCapture() noexcept = 0;
  virtual bool EndGraphCapture() noexcept = 0;
  virtual void ReplayGraph() noexcept = 0;
 
  // Memory

  virtual float* Allocate(size_t numFloats) = 0;
  virtual void Free(float* ptr) noexcept = 0;
  virtual void Zero(float* ptr, size_t numFloats) noexcept = 0;
  virtual void Copy(float* dst, const float* src, size_t numFloats) noexcept = 0;
  virtual void CopyFromHost(float* deviceDst, const float* hostSrc, size_t numFloats) noexcept = 0;
  virtual void CopyToHost(float* hostDst, const float* deviceSrc, size_t numFloats) noexcept = 0;
  virtual void RandomizeNormal(float* buf, size_t n, float mean, float stddev,
                               uint32_t seed) noexcept = 0;
  virtual void RandomizeUniform(float* buf, size_t n, float min, float max,
                                uint32_t seed) noexcept = 0;

  virtual void PrepareForBatchSize(size_t batchSize) noexcept = 0;
 
  // GEMM

  virtual void MatMul(bool transA, bool transB, int M, int N, int K, float alpha, const float* A,
                      int lda, const float* B, int ldb, float beta, float* C, int ldc) noexcept = 0;

  virtual void SumRows(float* dst, const float* src, size_t batchSize, size_t width) noexcept = 0;
 
  // Elementwise scalar ops

  virtual void Scale(float* buf, size_t n, float alpha) noexcept = 0;
  virtual void AxpyInto(float* y, const float* x, size_t n, float alpha) noexcept = 0;
  virtual void AddBiasBroadcast(float* buf, const float* bias, size_t batchSize,
                                size_t width) noexcept = 0;
 
  // Activation

  virtual void Activation(ActivationType type, float* buf, size_t n) noexcept = 0;
  virtual void ActivationInto(ActivationType type, float* dst, const float* src,
                              size_t n) noexcept = 0;
  virtual void ActivationDerivative(ActivationType type, float* buf, size_t n,
                                    bool activated) noexcept = 0;
  virtual void ActivationDerivativeInto(ActivationType type, float* dst, const float* src,
                                        size_t n) noexcept = 0;
 
  // Fused PC-specific ops

  virtual void FusedStateUpdateMomentum(float* z, float* v, const float* feedback,
                                        const float* deriv, const float* e, size_t n, float ir,
                                        float beta) noexcept = 0;

  virtual void FusedStateUpdate(float* z, const float* feedback, const float* deriv, const float* e,
                                size_t n, float ir) noexcept = 0;
  virtual float ComputeErrorAndEnergy(float* e, const float* z, const float* mu,
                                      size_t n) noexcept = 0;
  virtual void ComputeError(float* e, const float* z, const float* mu, size_t n) noexcept = 0;

  virtual float ComputeSoftmaxCrossEntropyErrorAndEnergy(float* e, const float* z, const float* mu,
                                                         size_t batchSize, size_t nextSize,
                                                         float* rowEnergies) noexcept = 0;

  virtual void ComputeSoftmaxCrossEntropyError(float* e, const float* z, const float* mu,
                                               size_t batchSize, size_t nextSize) noexcept = 0;

  virtual bool TryFusedForwardPass(ActivationType actType, const float* zF, const float* W,
                                   const float* bias, float* mu, int batchSize, int size,
                                   int nextSize) noexcept = 0;
 
  // Convolution (im2col-based, ConvPCLayer family)

  virtual void Im2Col(const float* input, int channels, int height, int width, int kernelH,
                      int kernelW, int strideH, int strideW, int padH, int padW,
                      float* columns) noexcept = 0;

  virtual void Col2Im(const float* columns, int channels, int height, int width, int kernelH,
                      int kernelW, int strideH, int strideW, int padH, int padW,
                      float* outputImage) noexcept = 0;

  virtual void RepackForBatchedGemm(float* dst, const float* src, size_t batchSize, size_t rows,
                                    size_t cols) noexcept = 0;
 
  // Optimizer

  virtual void IncrementCounter(int* counter) noexcept = 0;

  virtual void AdamStep(float* param, const float* grad, float* m, float* v, size_t n, const int* t,
                        const float* lr, float beta1 = 0.9f, float beta2 = 0.999f,
                        float eps = 1e-8f) noexcept = 0;
  virtual void AdamWStep(float* param, const float* grad, float* m, float* v, size_t n,
                         const int* t, const float* lr, float weightDecay, float beta1 = 0.9f,
                         float beta2 = 0.999f, float eps = 1e-8f) noexcept = 0;

  virtual DeviceType GetDeviceType() const noexcept = 0;

  virtual void MultiplyInto(float* dst, const float* a, const float* b, size_t n) noexcept = 0;
  virtual void Fill(float* buf, size_t n, float value) noexcept = 0;
  virtual void AddBiasPerChannel(float* buf, const float* bias, size_t channels,
                                 size_t spatialSize) noexcept = 0;
};
} // namespace Deep