用Boost.Proto构建特征表达模板
Constructing Eigen expression templates with Boost.Proto
我想使用Boost.Proto将嵌入式领域特定语言转换为使用Eigen库实现的一系列矩阵运算。由于效率很重要,我希望proto生成特征表达模板,避免过早评估。
我实现了一个简单的语法,可以生成矩阵乘法表达式。下面的代码编译时没有警告(在g++4.8.0和英特尔C++2013.3上,使用Boost 1.54.0和Eigen 3.1.3),只要我的表达式只有一个乘法运算,它就可以工作。一旦我在链上添加更多的乘法运算,它就会崩溃。Valgrind告诉我,这是因为其中一个Eigen::GeneralProduct表达式模板临时库在评估完成之前被销毁。
我不明白为什么会发生这种情况,也不明白我能做些什么来防止它。感谢所有的帮助!
#include <iostream>
#include <boost/fusion/container.hpp>
#include <boost/mpl/int.hpp>
#include <boost/mpl/void.hpp>
#include <boost/proto/proto.hpp>
#include <boost/ref.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/utility.hpp>
#include <Eigen/Dense>
namespace fusion = boost::fusion;
namespace mpl = boost::mpl;
namespace proto = boost::proto;
typedef Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic> matrix;
// Placeholders
const proto::terminal<mpl::int_<0> >::type I1 = {{}};
const proto::terminal<mpl::int_<1> >::type I2 = {{}};
const proto::terminal<mpl::int_<2> >::type I3 = {{}};
// Grammar
template<class Rule, class Callable = proto::callable>
struct External :
proto::when<Rule, proto::external_transform> {};
struct matmul_transform : proto::callable {
template<class Sig> struct result;
template<class This, class MatrixExpr1, class MatrixExpr2>
struct result<This(MatrixExpr1, MatrixExpr2)> {
typedef typename Eigen::ProductReturnType<
typename boost::remove_const<typename boost::remove_reference<MatrixExpr1>::type>::type,
typename boost::remove_const<typename boost::remove_reference<MatrixExpr2>::type>::type>::Type
type;
};
template<class MatrixExpr1, class MatrixExpr2>
typename result<matmul_transform(MatrixExpr1, MatrixExpr2)>::type
operator()(const MatrixExpr1 &a, const MatrixExpr2 &b) const {
return a * b;
}
};
struct MatmulGrammar;
struct InputPlaceholder : proto::terminal<proto::_> {};
struct MatrixMultiplication :
proto::multiplies<MatmulGrammar, MatmulGrammar> {};
struct MatmulGrammar : proto::or_<
External<InputPlaceholder>,
External<MatrixMultiplication> > {};
struct matmul_transforms : proto::external_transforms<
proto::when<MatrixMultiplication, matmul_transform(MatmulGrammar(proto::_left), MatmulGrammar(proto::_right))>,
proto::when<InputPlaceholder, proto::functional::at(proto::_data, proto::_value)> > {};
int main() {
matrix mat1(2,2), mat2(2,2), mat3(2,2), result(2,2);
mat1 << 1, 2, 3, 4;
mat2 << 5, 6, 7, 8;
mat3 << 1, 3, 6, 9;
MatmulGrammar mmg;
// THIS WORKS:
result = mmg(I1 * I2,
mpl::void_(),
(proto::data = fusion::make_vector(boost::cref(mat1), boost::cref(mat2), boost::cref(mat3)),
proto::transforms = matmul_transforms()));
std::cout << result << std::endl;
// THIS CRASHES:
result = mmg(I1 * I2 * I3,
mpl::void_(),
(proto::data = fusion::make_vector(boost::cref(mat1), boost::cref(mat2), boost::cref(mat3)),
proto::transforms = matmul_transforms()));
std::cout << result << std::endl;
return 0;
}
这是我尝试将您的方法与注释中链接的解决方案合并。我已经从这里复制了stored_result_expression
、do_wrap_expression
和wrap_expression
。我对您的代码或谈话中的代码所做的更改都用//CHANGED
标记。
#include <iostream>
#include <boost/fusion/container.hpp>
#include <boost/mpl/int.hpp>
#include <boost/mpl/void.hpp>
#include <boost/proto/proto.hpp>
#include <boost/ref.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/utility.hpp>
#include <Eigen/Dense>
namespace fusion = boost::fusion;
namespace mpl = boost::mpl;
namespace proto = boost::proto;
typedef Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic> matrix;
// Placeholders
const proto::terminal<mpl::int_<0> >::type I1 = {{}};
const proto::terminal<mpl::int_<1> >::type I2 = {{}};
const proto::terminal<mpl::int_<2> >::type I3 = {{}};
// Grammar
template<class Rule, class Callable = proto::callable>
struct External :
proto::when<Rule, proto::external_transform> {};
struct matmul_transform : proto::callable {
template<class Sig> struct result;
template<class This, class Expr, class MatrixExpr1, class MatrixExpr2>
struct result<This(Expr, MatrixExpr1, MatrixExpr2)> {
typedef typename Eigen::MatrixBase<
typename Eigen::ProductReturnType<
typename boost::remove_const<typename boost::remove_reference<MatrixExpr1>::type>::type,
typename boost::remove_const<typename boost::remove_reference<MatrixExpr2>::type>::type
>::Type
>::PlainObject&
type; //CHANGED - THIS IS THE TYPE THAT IS USED IN THE CODE OF THE TALK
};
template<class Expr, class MatrixExpr1, class MatrixExpr2>
typename result<matmul_transform(Expr, MatrixExpr1, MatrixExpr2)>::type
operator()(Expr& expr, const MatrixExpr1 &a, const MatrixExpr2 &b) const { //CHANGED - ADDED THE expr PARAMETER
expr.value = a*b;
return expr.value;
}
};
struct MatmulGrammar;
struct InputPlaceholder : proto::terminal<proto::_> {};
struct MatrixMultiplication :
proto::multiplies<MatmulGrammar, MatmulGrammar> {};
struct MatmulGrammar : proto::or_<
External<InputPlaceholder>,
External<MatrixMultiplication> > {};
struct matmul_transforms : proto::external_transforms<
proto::when<MatrixMultiplication, matmul_transform(proto::_, MatmulGrammar(proto::_left), MatmulGrammar(proto::_right))>, //CHANGED - ADAPTED TO THE NEW SIGNATURE OF matmul_transform
proto::when<InputPlaceholder, proto::functional::at(proto::_data, proto::_value)> > {};
// THE FOLLOWING CODE BLOCK IS COPIED FROM https://github.com/barche/eigen-proto/blob/master/eigen_calculator_solution.cpp
//----------------------------------------------------------------------------------------------
/// Wraps a given expression, so the value that it represents can be stored inside the expression itself
template<typename ExprT, typename ValueT>
struct stored_result_expression :
proto::extends< ExprT, stored_result_expression<ExprT, ValueT> >
{
EIGEN_MAKE_ALIGNED_OPERATOR_NEW
typedef proto::extends< ExprT, stored_result_expression<ExprT, ValueT> > base_type;
explicit stored_result_expression(ExprT const &expr = ExprT())
: base_type(expr)
{
}
/// Temporary storage for the result of the expression
mutable ValueT value;
};
struct do_wrap_expression : proto::transform< do_wrap_expression >
{
template<typename ExprT, typename StateT, typename DataT>
struct impl : proto::transform_impl<ExprT, StateT, DataT>
{
typedef typename boost::result_of<MatmulGrammar(ExprT, StateT, DataT)>::type result_ref_type; //CHANGED - TO USE YOUR GRAMMAR
typedef typename boost::remove_reference<result_ref_type>::type value_type;
typedef typename boost::remove_const<typename boost::remove_reference<ExprT>::type>::type expr_val_type;
typedef stored_result_expression<expr_val_type, value_type> result_type;
result_type operator()(typename impl::expr_param expr, typename impl::state_param state, typename impl::data_param data)
{
return result_type(expr);
}
};
};
/// Wrap multiplies expressions so they can store a temporary result
struct wrap_expression :
proto::or_
<
proto::terminal<proto::_>,
proto::when
<
proto::multiplies<proto::_, proto::_>,
do_wrap_expression(
proto::functional::make_multiplies
(
wrap_expression(proto::_left), wrap_expression(proto::_right)
),
proto::_state, //CHANGED - THESE EXTRA PARAMETERS ARE NEEDED TO CALCULATE result_ref_type IN do_wrap_expression
proto::_env
)
>,
proto::nary_expr< proto::_, proto::vararg<wrap_expression> >
>
{
};
//--------------------------------------------------------------------------------------------------
int main() {
matrix mat1(2,2), mat2(2,2), mat3(2,2), result(2,2);
mat1 << 1, 1, 0, 1;
mat2 << 1, 1, 0, 1;
mat3 << 1, 1, 0, 1;
MatmulGrammar mmg;
wrap_expression wrap;
//THIS WORKS:
result = mmg( //THIS IS REALLY HORRIBLE, BUT IT WORKS. IT SHOULD PROBABLY BE HIDDEN BEHIND A FUNCTION
wrap(
I1 * I2,
mpl::void_(),
( proto::data = fusion::make_vector(boost::cref(mat1), boost::cref(mat2), boost::cref(mat3)),
proto::transforms = matmul_transforms() )
),
mpl::void_(),
( proto::data = fusion::make_vector(boost::cref(mat1), boost::cref(mat2), boost::cref(mat3)),
proto::transforms = matmul_transforms() )
);
std::cout << result << std::endl;
// THIS DOESN'T CRASH ANYMORE:
result = mmg(
wrap(
I1 * I2 * I3 * I1 * I2 * I3,
mpl::void_(),
( proto::data = fusion::make_vector(boost::cref(mat1), boost::cref(mat2), boost::cref(mat3)),
proto::transforms = matmul_transforms() )
),
mpl::void_(),
( proto::data = fusion::make_vector(boost::cref(mat1), boost::cref(mat2), boost::cref(mat3)),
proto::transforms = matmul_transforms() )
);
std::cout << result << std::endl;
return 0;
}
这里有另一个似乎有效的解决方案。它不干扰proto的表达式对象,而是将指向中间Eigen对象的共享指针保存为状态的一部分。与受C++Now演讲启发的解决方案相比,它具有以下优势:
- 它不强制对Eigen的表达式模板进行早期评估
- 它需要对语法进行较少的更改,因此对特定领域语言的语法干扰较小
- 保持中间对象活动的责任由国家承担,可以说这就是它所属的地方。特别是,我相信这使得语法线程是安全的(如果proto是)
- 它返回一个表达式模板,而不是矩阵。即使您将此模板存储在变量中,并在以后有空时对其进行评估,您也应该是安全的,因为所有部分都包含在内
缺点:
- 你得到的不是一个整洁的矩阵,而是一个笨拙的结构,你必须从中提取你真正感兴趣的部分
- 临时对象是在堆上而不是在堆栈上分配的
- 如果你喜欢或不喜欢,你必须提供矩阵的共享指针
#include <iostream>
#include <boost/fusion/include/container.hpp>
#include <boost/fusion/include/join.hpp>
#include <boost/make_shared.hpp>
#include <boost/mpl/int.hpp>
#include <boost/mpl/void.hpp>
#include <boost/proto/proto.hpp>
#include <boost/ref.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/type_traits/remove_const.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <Eigen/Dense>
namespace fusion = boost::fusion;
namespace mpl = boost::mpl;
namespace proto = boost::proto;
typedef Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic> matrix;
// Placeholders
const proto::terminal<mpl::int_<0> >::type I1 = {{}};
const proto::terminal<mpl::int_<1> >::type I2 = {{}};
const proto::terminal<mpl::int_<2> >::type I3 = {{}};
// Grammar
template<class Rule, class Callable = proto::callable>
struct External :
proto::when<Rule, proto::external_transform> {};
struct matmul_transform : proto::callable {
template<class Sig> struct result;
template<class This, class ExprList1, class ExprList2>
struct result<This(ExprList1, ExprList2)> {
typedef typename boost::remove_reference<
typename fusion::result_of::front<ExprList1>::type>::type::element_type M1;
typedef typename boost::remove_reference<
typename fusion::result_of::front<ExprList2>::type>::type::element_type M2;
typedef typename Eigen::ProductReturnType<
typename boost::remove_const<typename boost::remove_reference<M1>::type>::type,
typename boost::remove_const<typename boost::remove_reference<M2>::type>::type>::Type
product_return_type;
typedef typename fusion::result_of::push_front<
const typename fusion::result_of::join<const ExprList1, const ExprList2>::type,
boost::shared_ptr<product_return_type> >::type
type;
};
template<class ExprList1, class ExprList2>
typename result<matmul_transform(ExprList1, ExprList2)>::type
operator()(const ExprList1 &a, const ExprList2 &b) const {
typedef typename result<matmul_transform(ExprList1, ExprList2)>::product_return_type product_return_type;
return push_front(join(a, b), boost::make_shared<product_return_type>(*front(a) * *front(b)));
}
};
struct placeholder_transform : proto::callable {
template<class Sig> struct result;
template<class This, class Data, class Value>
struct result<This(Data, Value)> {
typedef typename boost::remove_const<typename boost::remove_reference<
typename fusion::result_of::at<Data, typename boost::remove_reference<Value>::type>::type>
::type>::type ptr_type;
typedef typename fusion::list<ptr_type> type;
};
template<class Data, class Value>
typename result<placeholder_transform(Data, Value)>::type
operator()(Data &data, Value value) const {
return fusion::make_list(fusion::at<Value>(data));
}
};
struct MatmulGrammar;
struct InputPlaceholder : proto::terminal<proto::_> {};
struct MatrixMultiplication :
proto::multiplies<MatmulGrammar, MatmulGrammar> {};
struct MatmulGrammar : proto::or_<
External<InputPlaceholder>,
External<MatrixMultiplication> > {};
struct matmul_transforms : proto::external_transforms<
proto::when<MatrixMultiplication, matmul_transform(MatmulGrammar(proto::_left), MatmulGrammar(proto::_right))>,
proto::when<InputPlaceholder, placeholder_transform(proto::_data, proto::_value)> > {};
int main() {
boost::shared_ptr<matrix> mat1 = boost::make_shared<matrix>(2,2);
boost::shared_ptr<matrix> mat2 = boost::make_shared<matrix>(2,2);
boost::shared_ptr<matrix> mat3 = boost::make_shared<matrix>(2,2);
boost::shared_ptr<matrix> result = boost::make_shared<matrix>(2,2);
*mat1 << 1, 1, 0, 1;
*mat2 << 1, 1, 0, 1;
*mat3 << 1, 1, 0, 1;
MatmulGrammar mmg;
// THIS WORKS:
*result = *front(
mmg(I1 * I2, mpl::void_(),
(proto::data = fusion::make_vector(mat1, mat2, mat3),
proto::transforms = matmul_transforms())));
std::cout << *result << std::endl;
// THIS WORKS, TOO:
*result = *front(
mmg(I1 * I2 * I3 * I3 * I2 * I1, mpl::void_(),
(proto::data = fusion::make_vector(mat1, mat2, mat3),
proto::transforms = matmul_transforms())));
std::cout << *result << std::endl;
return 0;
}
相关文章:
- 理解boost::asio-async_read在无需读取内容时的行为
- boost::进程间消息队列引发错误
- 如何运行位于boost/libs/python/example/tutorial目录中的hello.cpp和Jamfil
- cmake如何在fedora工作站中找到boost静态库包
- CMake项目Boost库错误:Boost/config/compiler/gcc.hpp:165:10:致命错误:cs
- 如何声明特征矩阵,然后通过嵌套循环初始化它
- Boost Graph Library,修复节点大小
- 什么是"#include <boost/functional/hash.hpp> "?
- 基于boost的程序的静态链接——zlib问题
- C++:如何在CLion IDE中安装Boost
- 特征矩阵+Boost::序列化/C++17
- 寻找Boost转换迭代器的复合特征模式
- 在 boost::type_traits::条件中使用类型特征的编译错误
- 模板库的编译器内存消耗(boost + 特征)
- 将特征类型与 boost::bind 一起使用是否会自动违反 Eigen 的"only pass by reference"规则?
- 检查boost中的多边形特征
- 用Boost.Proto构建特征表达模板
- 为什么C++11没有纳入Boost的所有类型特征?
- Boost::融合,特征和压缩转换
- boost序列化特征矩阵为XML