介绍Expression template，本文是一个学习笔记，主要参考 mashadow项目关于表达式模板的教程
https://github.com/dmlc/mshadow/tree/master/guide/exp-template
- 类似matlab形式的向量操作如 VEC0 = VEC1 + VEC2 + VEC3存在效率问题
class Vec
{
public:
Vec(int len)
{
data.resize(len, 0);
Pval(&data[0]);
}
Vec()
{
LOG(INFO) << "Default construct";
}
~Vec()
{
LOG(INFO) << "Destruct";
}
Vec(const initializer_list<int>& il)
:data(il)
{
}
vector<int> data;
};
Vec test_return()
{
Vec vec;
return vec;
}
TEST(simple1, func)
{
Vec vec = test_return();
}
I0512 11:51:37.124034 22030 test_simple.cc:37] Default construct
I0512 11:51:37.124111 22030 test_simple.cc:41] Destruct
这证明了 c++会对返回值做优化 也就是说没有copy的代价 临时变量优化
对应vec = vec1 + vec2 类似的也是会有临时变量优化 不会有copy冗余代价 一次resize而已 3次destruct
TEST(simple2, func)
{
Vec b{ 3, 2, 1 }, c{ 2, 3, 4 };
Vec a = b + c;
}
I0512 11:57:51.699890 16547 test_simple.cc:33] &data[0] --- [0x8b0340]
I0512 11:57:51.699898 16547 test_simple.cc:58] vec.data --- 3
I0512 11:57:51.699903 16547 test_simple.cc:58] 0 5
I0512 11:57:51.699906 16547 test_simple.cc:58] 1 5
I0512 11:57:51.699911 16547 test_simple.cc:58] 2 5
I0512 11:57:51.699914 16547 test_simple.cc:41] Destruct
I0512 11:57:51.699919 16547 test_simple.cc:41] Destruct
I0512 11:57:51.699923 16547 test_simple.cc:41] Destruct
但是expression template还是有必要 比如比如
vec = vec1 + vec2 + vec3
这个时候临时开辟空间释放是逃不掉的 2次resize 4 + 1次destruct， 有一个次多余的resize 对应一次多余的destruct
TEST(simple3, func)
{
Vec b{ 3, 2, 1 }, c{ 2, 3, 4 }, d{ 123, 45, 30 };
Vec a = b + c + d;
}
I0512 11:59:40.398268 25704 test_simple.cc:33] &data[0] --- [0x8b1330]
I0512 11:59:40.398275 25704 test_simple.cc:58] vec.data --- 3
I0512 11:59:40.398279 25704 test_simple.cc:58] 0 5
I0512 11:59:40.398284 25704 test_simple.cc:58] 1 5
I0512 11:59:40.398288 25704 test_simple.cc:58] 2 5
I0512 11:59:40.398293 25704 test_simple.cc:33] &data[0] --- [0x8b1320]
I0512 11:59:40.398298 25704 test_simple.cc:58] vec.data --- 3
I0512 11:59:40.398304 25704 test_simple.cc:58] 0 128
I0512 11:59:40.398310 25704 test_simple.cc:58] 1 50
I0512 11:59:40.398318 25704 test_simple.cc:58] 2 35
I0512 11:59:40.398321 25704 test_simple.cc:41] Destruct
I0512 11:59:40.398325 25704 test_simple.cc:41] Destruct
I0512 11:59:40.398329 25704 test_simple.cc:41] Destruct
I0512 11:59:40.398334 25704 test_simple.cc:41] Destruct
I0512 11:59:40.398339 25704 test_simple.cc:41] Destruct
- 延迟计算( lazy evaluation)
当看到+的时候记忆下来不立即处理，当看到=的时候再分配一次空间 统一处理
A = B + C
教程里面给出了示例
exp_lazy.cpp 来自 <https://github.com/dmlc/mshadow/tree/master/guide/exp-template>
struct
BinaryAddExp {
const Vec &lhs;
const Vec &rhs;
BinaryAddExp(const Vec &lhs, const Vec &rhs)
: lhs(lhs), rhs(rhs) {}
};
// no constructor and destructor to allocate and de-allocate memory,
// allocation done by user
struct
Vec {
int len;
float* dptr;
Vec(void) {}
Vec(float *dptr, int len)
: len(len), dptr(dptr) {}
// here is where evaluation happens
inline Vec &operator=(const BinaryAddExp &src) {
for (int i = 0; i < len; ++i) {
dptr[i] = src.lhs.dptr[i] + src.rhs.dptr[i];
}
return *this;
}
};
// no evaluation happens here
inline BinaryAddExp operator+(const Vec &lhs, const Vec &rhs) {
return
BinaryAddExp(lhs, rhs);
}
但是
A = B + C + D
多个操作的时候如何传递这种操作记忆？ 只是延迟计算的话读一个一次+操作上面可以看到c++11已经可以处理多余的分配空间了
- 表达式模板(expression template)
类似教程中的 稍作改写 其实我们在执行=的时候 对应的是这样的类型
Exp<BinaryAddExp<BinaryAddExp<Vec, Vec>, Vec> >
这个是编译器在在编译期间确定好的
// this is expression, all expressions must inheritate it,
// and put their type in subtype
template<typename SubType>
struct Exp {
// returns const reference of the actual type of this expression
inline const SubType& self(void) const {
return *static_cast<const SubType*>(this);
}
};
// binary add expression
// note how it is inheritates from Exp
// and put its own type into the template argument
template<typename TLhs, typename TRhs>
struct BinaryAddExp : public Exp<BinaryAddExp<TLhs, TRhs> > {
const TLhs &lhs;
const TRhs &rhs;
BinaryAddExp(const TLhs& lhs, const TRhs& rhs)
: lhs(lhs), rhs(rhs) {}
// evaluation function, evaluate this expression at position i
inline float Eval(int i) const {
return lhs.Eval(i) + rhs.Eval(i);
}
inline size_t size()
{
return lhs.size();
}
};
class Vec : public Exp<Vec>
{
public:
Vec(int len)
{
data.resize(len, 0);
Pval(&data[0]);
}
Vec()
{
LOG(INFO) << "Default construct";
}
~Vec()
{
LOG(INFO) << "Destruct";
}
Vec(const initializer_list<int>& il)
:data(il)
{
}
inline size_t size()
{
return data.size();
}
// here is where evaluation happens
template<typename EType>
inline Vec& operator= (const Exp<EType>& src_) {
const EType &src = src_.self();
Pval(src.size());
data.resize(src.size());
for (size_t i = 0; i < src.size(); ++i) {
data[i] = src.Eval(i);
}
return *this;
}
// evaluation function, evaluate this expression at position i
inline int Eval(int i) const {
return data[i];
}
vector<int> data;
};
// template add, works for any expressions
template<typename TLhs, typename TRhs>
inline BinaryAddExp<TLhs, TRhs> operator+(const Exp<TLhs> &lhs, const Exp<TRhs> &rhs)
{
return BinaryAddExp<TLhs, TRhs>(lhs.self(), rhs.self());
}
void run()
{
Vec b{ 3, 2, 1 }, c{ 2, 3, 4 }, d{ 123, 45, 30 };
Vec a;
a = b + c + d;
Pvec(a.data);
}
4次析构 没有多余的构造
I0512 15:15:55.864331 16127 exp_template.cc:70] Default construct
I0512 15:15:55.864430 16127 exp_template.cc:90] src.size() --- [3]
I0512 15:15:55.864437 16127 exp_template.cc:119] a.data --- 3
I0512 15:15:55.864444 16127 exp_template.cc:119] 0 128
I0512 15:15:55.864449 16127 exp_template.cc:119] 1 50
I0512 15:15:55.864452 16127 exp_template.cc:119] 2 35
I0512 15:15:55.864456 16127 exp_template.cc:74] Destruct
I0512 15:15:55.864460 16127 exp_template.cc:74] Destruct
I0512 15:15:55.864464 16127 exp_template.cc:74] Destruct
I0512 15:15:55.864470 16127 exp_template.cc:74] Destruct
如果要支持
Vec a = b + c + d; //拷贝构造函数
需要增加
template<typename EType>
Vec(const Exp<EType>& src_)
{
*this = src_;
}
- 支持用户自定义的二元操作
类似下面的计算
A = B * F<maximum>(C, B);
// binary add expression
// note how it is inheritates from Exp
// and put its own type into the template argument
template<typename OP, typename TLhs, typename TRhs>
struct
BinaryMapExp: public
Exp<BinaryMapExp<OP, TLhs, TRhs> >{
const TLhs& lhs;
const TRhs& rhs;
BinaryMapExp(const TLhs& lhs, const TRhs& rhs)
:lhs(lhs), rhs(rhs) {}
// evaluation function, evaluate this expression at position i
inline
float
Eval(int i) const {
return
OP::Map(lhs.Eval(i), rhs.Eval(i));
}
};
// no constructor and destructor to allocate and de-allocate memory
// allocation done by user
struct
Vec: public
Exp<Vec>{
int len;
float* dptr;
Vec(void) {}
Vec(float *dptr, int len)
: len(len), dptr(dptr) {}
// here is where evaluation happens
template<typename EType>
inline Vec& operator=(const Exp<EType>& src_) {
const EType &src = src_.self();
for (int i = 0; i < len; ++i) {
dptr[i] = src.Eval(i);
}
return *this;
}
// evaluation function, evaluate this expression at position i
inline
float
Eval(int i) const {
return dptr[i];
}
};
// template add, works for any expressions
template<typename OP, typename TLhs, typename TRhs>
inline BinaryMapExp<OP, TLhs, TRhs>
F(const Exp<TLhs>& lhs, const Exp<TRhs>& rhs) {
return BinaryMapExp<OP, TLhs, TRhs>(lhs.self(), rhs.self());
}
template<typename TLhs, typename TRhs>
inline BinaryMapExp<mul, TLhs, TRhs>
operator*(const Exp<TLhs>& lhs, const Exp<TRhs>& rhs) {
return F<mul>(lhs, rhs);
}
// user defined operation
struct
maximum{
inline
static
float
Map(float a, float b) {
return a > b ? a : b;
}
};