tensor.h

Go to the documentation of this file.

#ifndef MSHADOW_TENSOR_H
#define MSHADOW_TENSOR_H

#include "tensor_base.h"
#include "tensor_expr.h"

namespace mshadow {
    template<int dimension>
    struct Shape {
    public:
        const static int kMaxShape = dimension;
        const static int kSubShape = dimension - 1;
    public:
        MSHADOW_XINLINE Shape(void) {}
        MSHADOW_XINLINE Shape( const Shape<dimension> &s ){
            #pragma unroll
            for( int i = 0; i < kMaxShape; ++i ){
                this->shape_[i] = s[i];
            }
            this->stride_ = s.stride_;
        }
        MSHADOW_XINLINE index_t& operator[](index_t idx) {
            return shape_[ idx ];
        }
        MSHADOW_XINLINE const index_t& operator[](index_t idx) const {
            return shape_[ idx ];
        }
        MSHADOW_XINLINE bool operator==(const Shape<kMaxShape> &s) const {
            #pragma unroll
            for ( int i = 0; i < kMaxShape; ++i ) {
                if (s.shape_[i] != this->shape_[i]) return false;
            }
            return true;
        }
        MSHADOW_XINLINE Shape<2> FlatTo2D(void) const {
            Shape<2> s;
            s.stride_ = this->stride_;
            s.shape_[ 0 ] = this->shape_[ 0 ];
            index_t ymax = 1;

            #pragma unroll
            for (int i = 1; i < kMaxShape; ++i) {
                ymax *= this->shape_[ i ];
            }
            s.shape_[1] = ymax;
            return s;
        }
        MSHADOW_XINLINE size_t Size(void) const{
            size_t memsz = this->shape_[ 0 ];
            #pragma unroll
            for (int i = 1; i < kMaxShape; ++i) {
                memsz *= this->shape_[ i ];
            }
            return memsz;
        }
        MSHADOW_XINLINE size_t MSize(void) const {
            size_t memsz = this->stride_;
            #pragma unroll
            for (int i = 1; i < kMaxShape; ++i) {
                memsz *= this->shape_[ i ];
            }
            return memsz;
        }
        MSHADOW_XINLINE index_t ProdShape( int dimstart, int dimend ) const{
            index_t num = 1;
            #pragma unroll
            for (int i = dimstart; i < dimend; ++i) {
                num *= this->shape_[ i ];
            }
            return num;
        }
        MSHADOW_XINLINE Shape<kSubShape> SubShape(void) const {
            Shape<kSubShape> s;
            s.stride_ = this->stride_;
            // for cuda
            #pragma unroll
            for (int i = 0; i < kSubShape; ++i) {
                s.shape_[ i ] = this->shape_[ i ];
            }
            return s;
        }

    public:
        index_t shape_[ kMaxShape ];
        index_t stride_;
    };
    // useful construction functions to generate shape
    MSHADOW_XINLINE Shape<1> Shape1( index_t s0 ){
        Shape<1> s; s[0] = s0; s.stride_ = s0;
        return s;
    }
    MSHADOW_XINLINE Shape<2> Shape2( index_t s1, index_t s0 ){
        Shape<2> s; s[0] = s0; s[1] = s1; s.stride_ = s0;
        return s;
    }
    MSHADOW_XINLINE Shape<3> Shape3( index_t s2, index_t s1, index_t s0 ){
        Shape<3> s;
        s[0] = s0; s[1] = s1; s[2] = s2; s.stride_ = s0;
        return s;
    }
    MSHADOW_XINLINE Shape<4> Shape4( index_t s3, index_t s2, index_t s1, index_t s0 ){
        Shape<4> s;
        s[0] = s0; s[1] = s1; s[2] = s2; s[3] = s3; s.stride_ = s0;
        return s;
    }
}; // namespace mshadow

namespace mshadow {
    struct cpu {
        const static bool kDevCPU = true;
        const static int kDevMask = 1<<0;
    };
    struct gpu {
        const static bool kDevCPU = false;
        const static int kDevMask = 1<<1;
    };

    // more compact template
    template<typename Device, int dimension>
    struct Tensor: public expr::ContainerExp< Tensor<Device,dimension> >{
    public:
        const static bool kDevCPU = Device::kDevCPU;
        const static int  kSubdim = dimension - 1;

    public:
        real_t *dptr;
        Shape<dimension> shape;
    public:
        MSHADOW_XINLINE Tensor(void) {}
        MSHADOW_XINLINE Tensor(const Shape<dimension> &shape): shape(shape) {}
        MSHADOW_XINLINE Tensor(real_t *dptr, const Shape<dimension> &shape): dptr((real_t*)dptr), shape(shape) {}
        MSHADOW_XINLINE Tensor<Device, 2> FlatTo2D(void) const {
            return Tensor<Device, 2>(reinterpret_cast<real_t*> \
                                     (dptr), shape.FlatTo2D());
        }
        MSHADOW_XINLINE Tensor<Device, kSubdim> operator[](index_t idx) const {
            Shape<kSubdim> s = shape.SubShape();
            return Tensor<Device, kSubdim>(reinterpret_cast<real_t*> \
                                           (dptr) + s.MSize() * idx, s);
        }
        MSHADOW_XINLINE Tensor<Device, dimension> Slice(index_t begin, index_t end) const {
            Shape<dimension> s = this->shape;
            s[ dimension - 1 ] = end - begin;
            return Tensor<Device, dimension>(reinterpret_cast<real_t*>\
                                             (dptr) + s.SubShape().MSize() * begin, s);
        }
    public:
        inline Tensor<Device,dimension>& operator=( real_t s ){
            return this->__assign( s );
        }
        template<typename E>
        inline Tensor<Device,dimension>& operator=( const expr::Exp<E,expr::type::kMapper> &exp ){
            return this->__assign( exp );
        }
        template<typename E>
        inline Tensor<Device,dimension>& operator=( const expr::Exp<E,expr::type::kComplex> &exp ){
            return this->__assign( exp );
        }
    };

    /*
     *  respecialized class Tensor1D,thei is due to different implementation in operator[]
     */
    template<typename Device>
    struct Tensor<Device,1>: public expr::ContainerExp< Tensor<Device,1> >{
    public:
        real_t *dptr;
        Shape<1> shape;
    public:
        MSHADOW_XINLINE Tensor(void) {}
        MSHADOW_XINLINE Tensor(const Shape<1> &shape): shape(shape) {}
        MSHADOW_XINLINE Tensor(real_t *dptr, Shape<1> shape) :dptr(dptr), shape(shape) {}

        MSHADOW_XINLINE Tensor<Device, 2> FlatTo2D(void) const {
            return Tensor<Device, 2>(reinterpret_cast<real_t*> \
                                     (dptr), shape.FlatTo2D());
        }
        MSHADOW_XINLINE Tensor<Device, 1> Slice(index_t begin, index_t end) const {
            Shape<1> s;
            s[0] = s.stride_ = end  - begin;
            return Tensor<Device, 1>(reinterpret_cast<real_t*> \
                                     (dptr) + begin, s);
        }
        MSHADOW_XINLINE real_t &operator[](index_t idx) { return dptr[ idx ]; }
        MSHADOW_XINLINE const real_t &operator[](index_t idx)const { return dptr[ idx ]; }
    public:
        // functions to fit expression template
        inline Tensor<Device,1>& operator=( double s ){
            return this->__assign( s );
        }
        template<typename E>
        inline Tensor<Device,1>& operator=( const expr::Exp<E,expr::type::kMapper> &exp ){
            return this->__assign( exp );
        }
        template<typename E>
        inline Tensor<Device,1>& operator=( const expr::Exp<E,expr::type::kComplex> &exp ){
            return this->__assign( exp );
        }
    };
}; // namespace mshadow

// add unroll loops for the shape
namespace mshadow {
    // function declarations
    inline void InitTensorEngine( int device_id=0 );
    inline void ShutdownTensorEngine( void );

    template<int dim>
    inline void AllocSpace(Tensor<cpu,dim> &obj, bool pad = MSHADOW_ALLOC_PAD);
    template<int dim>
    inline void AllocSpace(Tensor<gpu,dim> &obj, bool pad = MSHADOW_ALLOC_PAD);

    template<int dim>
    inline void FreeSpace(Tensor<cpu,dim> &obj);
    template<int dim>
    inline void FreeSpace(Tensor<gpu,dim> &obj);

    template<typename Device, int dim>
    inline Tensor<Device,dim> NewTensor(const Shape<dim> &shape, real_t initv, bool pad = MSHADOW_ALLOC_PAD);

    template<int dim>
    inline void Copy(Tensor<cpu,dim> dst, const Tensor<cpu,dim> &src );
    template<int dim>
    inline void Copy(Tensor<cpu,dim> dst, const Tensor<gpu,dim> &src );
    template<int dim>
    inline void Copy(Tensor<gpu,dim> dst, const Tensor<cpu,dim> &src );
    template<int dim>
    inline void Copy(Tensor<gpu,dim> dst, const Tensor<gpu,dim> &src );


    inline void Softmax( Tensor<cpu,2> dst, const Tensor<cpu,2> &energy );
    inline void Softmax( Tensor<gpu,2> dst, const Tensor<gpu,2> &energy );

}; // namespace mshadow


namespace mshadow{
    // function declarations to support expression, no need to understand them
    // these functions do not need to be directly used

    template<typename Saver, int dim, typename E, int etype>
    inline void MapExp(Tensor<cpu,dim> dst, const expr::Exp<E,etype> &exp );
    template<typename Saver, int dim, typename E, int etype>
    inline void MapExp(Tensor<gpu,dim> dst, const expr::Exp<E,etype> &exp );

    template<typename Saver, typename Reducer, typename E, int etype>
    inline void MapReduceKeepLowest( Tensor<cpu,1> dst, const expr::Exp<E,etype> &exp, real_t scale = 1.0f );
    template<typename Saver, typename Reducer, typename E, int etype>
    inline void MapReduceKeepLowest( Tensor<gpu,1> dst, const expr::Exp<E,etype> &exp, real_t scale = 1.0f );


    template<typename Saver, typename Reducer, int dimkeep, typename E, int etype>
    inline void MapReduceKeepHighDim( Tensor<cpu,1> dst, const expr::Exp<E,etype> &exp, real_t scale = 1.0f );
    template<typename Saver, typename Reducer, int dimkeep, typename E, int etype>
    inline void MapReduceKeepHighDim( Tensor<gpu,1> dst, const expr::Exp<E,etype> &exp, real_t scale = 1.0f );

};// namespace mshadow

// execution implementation of expression evaluations
#include "tensor_expr_engine-inl.hpp"
// cpu implementation of functions
#include "tensor_cpu-inl.hpp"
// gpu implementation of functions
#include "tensor_gpu-inl.hpp"
// extension of expressions
#include "tensor_expr_ext.h"
// io 
#include "tensor_io.h"
// container
#include "tensor_container.h"
// random number generator
#include "tensor_random.h"
#endif // TENSOR_H