packing.hpp

#ifndef PACKING_HPP
#define PACKING_HPP

namespace hmlp
{



template<size_t NB, typename T, typename TPACK>
struct pack_pbxib
{
  inline virtual void operator ()
  (
    size_t k, size_t pc, size_t pb,
    size_t m, size_t ic, size_t ib,
    T *X,
    TPACK *packX
  ) = 0;

}; 
template<size_t NB, typename T, typename TPACK>
struct unpack_ibxjb
{
  size_t rs_c = 0;
  size_t cs_c = 0;

  inline virtual void operator ()
  (
    size_t m, size_t ic, size_t ib,
    size_t n, size_t jc, size_t jb,
    T *X,
    TPACK *packX
  ) = 0;

}; 
template<int NB, typename T, typename TPACK>
struct pack2D_pbxib : public pack_pbxib<NB, T, TPACK>
{
  bool trans = false;
  size_t ldx = 0;

  inline virtual void operator ()
  (
    size_t k, size_t pc, size_t pb,
    size_t m, size_t ic, size_t ib,
    T *X,
    TPACK *packX
  )
  {
    T *x_pntr[ NB ];

    if ( trans )
    {
      X += ( ic * ldx + pc );

      for ( auto i = 0; i < ib; i ++ )
      {
        x_pntr[ i ] = X + ldx * i;
      }
      for ( auto i = ib; i < NB; i ++ )
      {
        x_pntr[ i ] = X;
      }

      for ( auto p = 0; p < pb; p ++ ) 
      {
        for ( auto i = 0; i < ib; i ++ )
        {
          *packX ++ = *x_pntr[ i ] ++;
        }
        for ( auto i = ib; i < NB; i ++ )
        {
          *packX ++ = 0;
        }
      }
    }
    else 
    {
      X += ( pc * ldx + ic );

      for ( auto i = 0; i < ib; i ++ )
      {
        x_pntr[ i ] = X + i;
      }
      for ( auto i = ib; i < NB; i ++ )
      {
        x_pntr[ i ] = X;
      }

      for ( auto p = 0; p < pb; p ++ )
      {
        for ( auto i = 0; i < ib; i ++ )
        {
          *packX = *x_pntr[ i ];
          packX ++;
          x_pntr[ i ] += ldx;
        }
        for ( auto i = ib; i < NB; i ++ )
        {
          *packX ++ = 0;
        }
      }
    }
  };
}; 
template<size_t NB, typename T, typename TPACK>
struct unpack2D_ibxjb : public unpack_ibxjb<NB, T, TPACK>
{
  inline virtual void operator ()
  (
    size_t m, size_t ic, size_t ib,
    size_t n, size_t jc, size_t jb,
    T *X,
    TPACK *packX
  )
  {
    for ( size_t j = 0; j < jb; j ++ )
      for ( size_t i = 0; i < ib; i ++ )
        X[ ( jc + j ) * this->cs_c + ( ic + i ) * this->rs_c ] 
          = packX[ j * NB + i ];
  };

}; 
template<size_t NB, typename T, typename TPACK>
struct MatrifyableObject
{
  size_t m = 0;
  size_t n = 0;

  inline virtual void Pack
  (
    size_t m, size_t ic, size_t ib,
    size_t n, size_t jc, size_t jb,
    TPACK *packX
  ) = 0;

  inline virtual void Unpack
  (
    size_t m, size_t ic, size_t ib,
    size_t n, size_t jc, size_t jb,
    TPACK *packX
  ) = 0;

}; 
template<size_t NB, typename T, typename TPACK>
struct MatrixLike : public MatrifyableObject<NB, T, TPACK>
{
  T* X = NULL;

  size_t rs = 0;

  size_t cs = 0;

  bool trans = false;

  inline virtual void Set( T* X, size_t m, size_t n, size_t rs, size_t cs, bool trans )
  {
    this->X = X;
    this->m = m;
    this->n = n;
    this->rs = rs;
    this->cs = cs;
    this->trans = trans;
  };

  inline virtual void Pack
  (
    size_t m, size_t ic, size_t ib,
    size_t n, size_t jc, size_t jb,
    TPACK *packX
  ) 
  {
    T *x_pntr[ NB ];

    T *x = X + ic * rs + jc * cs;

    if ( trans )
    {
      for ( size_t j =  0; j < jb; j ++ ) x_pntr[ j ] = x + j * cs;

      for ( size_t i =  0; i < ib; i ++ )
      {
        for ( size_t j =  0; j < jb; j ++ ) 
        {
          *packX ++ = *x_pntr[ j ];
          x_pntr[ j ] += rs;
        }
        for ( size_t j = jb; j < NB; j ++ ) *packX ++ = 0;
      }
    }
    else
    {
      for ( size_t i =  0; i < ib; i ++ ) x_pntr[ i ] = x + i * rs;
      //for ( size_t i = ib; i < NB; i ++ ) x_pntr[ i ] = x;

      for ( size_t j =  0; j < jb; j ++ )
      {
        for ( size_t i =  0; i < ib; i ++ ) 
        {
          *packX ++ = *x_pntr[ i ];
          x_pntr[ i ] += cs;
        }
        for ( size_t i = ib; i < NB; i ++ ) *packX ++ = 0;
      }
    }
  };

  inline virtual void Unpack
  (
    size_t m, size_t ic, size_t ib,
    size_t n, size_t jc, size_t jb,
    TPACK *packX
  ) 
  {
    T *x_pntr[ NB ];

    T *x = X + ic * rs + jc * cs;

    if ( trans )
    {
      for ( size_t j =  0; j < jb; j ++ ) x_pntr[ j ] = x + j * cs;

      for ( size_t i =  0; i < ib; i ++ )
      {
        for ( size_t j =  0; j < jb; j ++ ) 
        {
          *x_pntr[ j ] = *packX ++;
          x_pntr[ j ] += rs;
        }
        for ( size_t j = jb; j < NB; j ++ ) packX ++;
      }
    }
    else
    {
      for ( size_t i =  0; i < ib; i ++ ) x_pntr[ i ] = x + i * rs;
      //for ( size_t i = ib; i < NB; i ++ ) x_pntr[ i ] = x;

      for ( size_t j =  0; j < jb; j ++ )
      {
        for ( size_t i =  0; i < ib; i ++ ) 
        {
          *x_pntr[ i ] = *packX ++;
          x_pntr[ i ] += cs;
        }
        for ( size_t i = ib; i < NB; i ++ ) packX ++;
      }
    }
  };



}; 
}; 
#endif