gaspersic/triton
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

various changes

Browse Source
This commit is contained in:
Philippe Tillet
2015-01-17 15:47:52 -05:00
parent 0068560bc6
commit 16648f18e0
14 changed files with 134 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
include/atidlas/backend/mapped_object.h
View File

@@ -206,14 +206,6 @@ public:
mapped_vdiag(std::string const & scalartype, unsigned int id, node_info info);
};
class mapped_trans: public mapped_object, public binary_leaf
{
private:
void postprocess(std::string &res) const;
public:
mapped_trans(std::string const & scalartype, unsigned int id, node_info info);
};
class mapped_matrix_row : public mapped_object, binary_leaf
{
private:

7
lib/array.cpp
View File

@@ -26,8 +26,7 @@ array::array(std::vector<T> const & x, cl::Context context):
array::array(array & v, slice const & s1) : dtype_(v.dtype_), shape_(s1.size, 1), start_(v.start_._1 + v.stride_._1*s1.start, 0), stride_(v.stride_._1*s1.stride, 1),
ld_(v.ld_), context_(v.data_.getInfo<CL_MEM_CONTEXT>()), data_(v.data_)
{
}
{}
#define INSTANTIATE(T) template array::array<T>(std::vector<T> const &, cl::Context)
INSTANTIATE(cl_char);
@@ -122,6 +121,7 @@ array& array::reshape(int_t size1, int_t size2)
{
assert(size1*size2==prod(shape_));
shape_ = size4(size1, size2);
ld_ = size1;
return *this;
}
@@ -591,7 +591,8 @@ namespace detail
int_t N = A.shape()._2;
symbolic_expression_node & A_root = const_cast<symbolic_expression_node &>(A.tree()[A.root()]);
bool A_trans = A_root.op.type==OPERATOR_TRANS_TYPE;
if(A_trans){
if(A_trans)
{
array_expression tmp(A, repmat(const_cast<T&>(x), 1, M), op_element(OPERATOR_BINARY_TYPE_FAMILY, OPERATOR_ELEMENT_PROD_TYPE), size4(N, M));
//Remove trans
tmp.tree()[tmp.root()].lhs = A.tree()[A.root()].lhs;

45
lib/backend/mapped_object.cpp
View File

@@ -223,14 +223,23 @@ void mapped_array::preprocess(std::string & str) const
replace_macro(str, "$OFFSET", MorphOffset(ld_, type_));
}
mapped_array::mapped_array(std::string const & scalartype, unsigned int id, char type) : mapped_buffer(scalartype, id, "array"), type_(type)
mapped_array::mapped_array(std::string const & scalartype, unsigned int id, char type) : mapped_buffer(scalartype, id, type=='m'?"array2":"array1"), type_(type)
{
register_attribute(ld_, "#ld", name_ + "_ld");
register_attribute(start1_, "#start1", name_ + "_start1");
register_attribute(start2_, "#start2", name_ + "_start2");
register_attribute(stride1_, "#stride1", name_ + "_stride1");
register_attribute(stride2_, "#stride2", name_ + "_stride2");
keywords_["#nldstride"] = "#stride2";
if(type_=='m')
{
register_attribute(start1_, "#start1", name_ + "_start1");
register_attribute(start2_, "#start2", name_ + "_start2");
register_attribute(stride1_, "#stride1", name_ + "_stride1");
register_attribute(stride2_, "#stride2", name_ + "_stride2");
register_attribute(ld_, "#ld", name_ + "_ld");
keywords_["#nldstride"] = "#stride2";
}
else
{
register_attribute(start1_, "#start", name_ + "_start");
register_attribute(stride1_, "#stride", name_ + "_stride");
}
}
//
@@ -238,29 +247,20 @@ void mapped_vdiag::postprocess(std::string &res) const
{
std::map<std::string, std::string> accessors;
tools::find_and_replace(res, "#diag_offset", atidlas::evaluate(RHS_NODE_TYPE, accessors, *info_.symbolic_expression, info_.root_idx, *info_.mapping));
accessors["array"] = res;
accessors["array1"] = res;
accessors["host_scalar"] = res;
res = atidlas::evaluate(LHS_NODE_TYPE, accessors, *info_.symbolic_expression, info_.root_idx, *info_.mapping);
}
mapped_vdiag::mapped_vdiag(std::string const & scalartype, unsigned int id, node_info info) : mapped_object(scalartype, id, "vdiag"), binary_leaf(info){}
//
void mapped_trans::postprocess(std::string &res) const
{
std::map<std::string, std::string> accessors;
accessors["array"] = res;
res = atidlas::evaluate(LHS_NODE_TYPE, accessors, *info_.symbolic_expression, info_.root_idx, *info_.mapping);
}
mapped_trans::mapped_trans(std::string const & scalartype, unsigned int id, node_info info) : mapped_object(scalartype, id, "matrix_trans"), binary_leaf(info){ }
//
void mapped_matrix_row::postprocess(std::string &res) const
{
std::map<std::string, std::string> accessors;
tools::find_and_replace(res, "#row", atidlas::evaluate(RHS_NODE_TYPE, accessors, *info_.symbolic_expression, info_.root_idx, *info_.mapping));
accessors["array"] = res;
accessors["array2"] = res;
res = atidlas::evaluate(LHS_NODE_TYPE, accessors, *info_.symbolic_expression, info_.root_idx, *info_.mapping);
}
@@ -272,7 +272,7 @@ void mapped_matrix_column::postprocess(std::string &res) const
{
std::map<std::string, std::string> accessors;
tools::find_and_replace(res, "#column", atidlas::evaluate(RHS_NODE_TYPE, accessors, *info_.symbolic_expression, info_.root_idx, *info_.mapping));
accessors["array"] = res;
accessors["array2"] = res;
res = atidlas::evaluate(LHS_NODE_TYPE, accessors, *info_.symbolic_expression, info_.root_idx, *info_.mapping);
}
@@ -288,7 +288,8 @@ void mapped_repeat::postprocess(std::string &res) const
tools::find_and_replace(res, "#tuplearg1", args.process("#tuplearg1"));
tools::find_and_replace(res, "#tuplearg2", args.process("#tuplearg2"));
tools::find_and_replace(res, "#tuplearg3", args.process("#tuplearg3"));
accessors["array"] = res;
accessors["array1"] = res;
accessors["array2"] = res;
res = atidlas::evaluate(LHS_NODE_TYPE, accessors, *info_.symbolic_expression, info_.root_idx, *info_.mapping);
}
@@ -301,7 +302,7 @@ void mapped_matrix_diag::postprocess(std::string &res) const
{
std::map<std::string, std::string> accessors;
tools::find_and_replace(res, "#diag_offset", atidlas::evaluate(RHS_NODE_TYPE, accessors, *info_.symbolic_expression, info_.root_idx, *info_.mapping));
accessors["array"] = res;
accessors["array2"] = res;
res = atidlas::evaluate(LHS_NODE_TYPE, accessors, *info_.symbolic_expression, info_.root_idx, *info_.mapping);
}
@@ -317,7 +318,7 @@ void mapped_outer::postprocess(std::string &res) const
std::string operator()(std::string const & i) const
{
std::map<std::string, std::string> accessors;
accessors["array"] = "$VALUE{"+i+"}";
accessors["array1"] = "$VALUE{"+i+"}";
return atidlas::evaluate(leaf_, accessors, *i_.symbolic_expression, i_.root_idx, *i_.mapping);
}
std::string operator()(std::string const &, std::string const &) const{return "";}

23
lib/backend/templates/base.cpp
View File

@@ -107,8 +107,6 @@ void base::map_functor::operator()(atidlas::symbolic_expression const & symbolic
mapping_.insert(mapping_type::value_type(key, binary_leaf<mapped_mreduction>(&symbolic_expression, root_idx, &mapping_)));
else if (root_node.op.type_family == OPERATOR_MATRIX_PRODUCT_TYPE_FAMILY)
mapping_.insert(mapping_type::value_type(key, binary_leaf<mapped_mproduct>(&symbolic_expression, root_idx, &mapping_)));
else if (root_node.op.type == OPERATOR_TRANS_TYPE)
mapping_.insert(mapping_type::value_type(key, binary_leaf<mapped_trans>(&symbolic_expression, root_idx, &mapping_)));
else if (root_node.op.type == OPERATOR_REPEAT_TYPE)
mapping_.insert(mapping_type::value_type(key, binary_leaf<mapped_repeat>(&symbolic_expression, root_idx, &mapping_)));
else if (root_node.op.type == OPERATOR_OUTER_PROD_TYPE)
@@ -152,11 +150,19 @@ void base::set_arguments_functor::set_arguments(array const & x) const
else
{
kernel_.setArg(current_arg_++, x.data());
kernel_.setArg(current_arg_++, cl_uint(x.ld()));
kernel_.setArg(current_arg_++, cl_uint(x.start()._1));
kernel_.setArg(current_arg_++, cl_uint(x.start()._2));
kernel_.setArg(current_arg_++, cl_uint(x.stride()._1));
kernel_.setArg(current_arg_++, cl_uint(x.stride()._2));
if(x.nshape()==1)
{
kernel_.setArg(current_arg_++, cl_uint(max(x.start())));
kernel_.setArg(current_arg_++, cl_uint(max(x.stride())));
}
else
{
kernel_.setArg(current_arg_++, cl_uint(x.ld()));
kernel_.setArg(current_arg_++, cl_uint(x.start()._1));
kernel_.setArg(current_arg_++, cl_uint(x.start()._2));
kernel_.setArg(current_arg_++, cl_uint(x.stride()._1));
kernel_.setArg(current_arg_++, cl_uint(x.stride()._2));
}
}
}
}
@@ -265,7 +271,8 @@ std::string base::generate_arguments(std::string const & data_type, std::vector<
{
return generate_arguments(mappings, tools::make_map<std::map<std::string, std::string> >("scalar", "__global #scalartype* #pointer,")
("host_scalar", "#scalartype #name,")
("array", "__global " + data_type + "* #pointer, uint #ld, uint #start1, uint #start2, uint #stride1, uint #stride2,")
("array1", "__global " + data_type + "* #pointer, uint #start, uint #stride,")
("array2", "__global " + data_type + "* #pointer, uint #ld, uint #start1, uint #start2, uint #stride1, uint #stride2,")
("tuple4", "#scalartype #name0, #scalartype #name1, #scalartype #name2, #scalartype #name3,"), symbolic_expressions);
}

10
lib/backend/templates/maxpy.cpp
View File

@@ -35,7 +35,7 @@ std::string maxpy::generate_impl(unsigned int label, symbolic_expressions_contai
stream.inc_tab();
process(stream, PARENT_NODE_TYPE, tools::make_map<std::map<std::string, std::string> >("scalar", "#scalartype #namereg = *#pointer;")
("array", "#pointer = &$VALUE{#start1, #start2};"), symbolic_expressions, mappings);
("array2", "#pointer = &$VALUE{#start1, #start2};"), symbolic_expressions, mappings);
fetching_loop_info(p_.fetching_policy, "M", stream, init0, upper_bound0, inc0, "get_global_id(0)", "get_global_size(0)");
stream << "for(unsigned int i = " << init0 << "; i < " << upper_bound0 << "; i += " << inc0 << ")" << std::endl;
@@ -47,21 +47,21 @@ std::string maxpy::generate_impl(unsigned int label, symbolic_expressions_contai
stream.inc_tab();
process(stream, PARENT_NODE_TYPE, tools::make_map<std::map<std::string, std::string> >
("array", append_width("#scalartype",simd_width) + " #namereg = $VALUE{i*#stride1,j*#stride2};")
("array2", append_width("#scalartype",simd_width) + " #namereg = $VALUE{i*#stride1,j*#stride2};")
("vdiag", "#scalartype #namereg = ((i + ((#diag_offset<0)?#diag_offset:0))!=(j-((#diag_offset>0)?#diag_offset:0)))?0:$VALUE{min(i*#stride1, j*#stride1)};")
("repeat", "#scalartype #namereg = $VALUE{(i%#tuplearg0)*#stride1, (j%#tuplearg1)*#stride2};")
("outer", "#scalartype #namereg = ($LVALUE{i*#stride1})*($RVALUE{j*#stride1});")
("outer", "#scalartype #namereg = ($LVALUE{i*#stride})*($RVALUE{j*#stride});")
, symbolic_expressions, mappings);
evaluate(stream, PARENT_NODE_TYPE, tools::make_map<std::map<std::string, std::string> >
("array", "#namereg")
("array2", "#namereg")
("vdiag", "#namereg")
("repeat", "#namereg")
("scalar", "#namereg")
("outer", "#namereg")
, symbolic_expressions, mappings);
process(stream, LHS_NODE_TYPE, tools::make_map<std::map<std::string, std::string> >("array", "$VALUE{i*#stride1,j*#stride2} = #namereg;")
process(stream, LHS_NODE_TYPE, tools::make_map<std::map<std::string, std::string> >("array2", "$VALUE{i*#stride1,j*#stride2} = #namereg;")
, symbolic_expressions, mappings);
stream.dec_tab();

21
lib/backend/templates/mreduction.cpp
View File

@@ -43,9 +43,9 @@ std::string mreduction::generate_impl(unsigned int label, symbolic_expressions_c
process(stream, PARENT_NODE_TYPE,
tools::make_map<std::map<std::string, std::string> >("scalar", "#scalartype #namereg = *#pointer;")
("array", "#pointer += #start1 + #start2*#ld;")
("array", "#ld *= #nldstride;")
("array", "#pointer += #start1;"), symbolic_expressions, mappings);
("array1", "#pointer += #start;")
("array2", "#pointer += #start1 + #start2*#ld; "
"#ld *= #nldstride; "), symbolic_expressions, mappings);
for (std::vector<mapped_mreduction*>::const_iterator it = exprs.begin(); it != exprs.end(); ++it)
stream << (*it)->process("__local #scalartype #name_buf[" + to_string(lsize0*lsize1) + "];") << std::endl;
@@ -75,11 +75,16 @@ std::string mreduction::generate_impl(unsigned int label, symbolic_expressions_c
for (std::vector<mapped_mreduction*>::const_iterator it = exprs.begin(); it != exprs.end(); ++it)
{
std::map<std::string, std::string> accessors;
accessors["repeat"] = "#scalartype #namereg = $VALUE{(r%#tuplearg0)*#stride1, (c%#tuplearg1)*#stride2};";
if(reduction==REDUCE_COLUMNS)
accessors["array"] = data_type + " #namereg = " + vload(simd_width, "c*#stride1", "#pointer + r*#ld")+";";
{
accessors["array2"] = data_type + " #namereg = " + vload(simd_width, "c*#stride1", "#pointer + r*#ld")+";";
accessors["repeat"] = "#scalartype #namereg = $VALUE{(c%#tuplearg0)*#stride, (r%#tuplearg1)*#stride};";
}
else
accessors["array"] = "#scalartype #namereg = #pointer[r*#stride1 + c*#ld];";
{
accessors["array2"] = "#scalartype #namereg = #pointer[r*#stride1 + c*#ld];";
accessors["repeat"] = "#scalartype #namereg = $VALUE{(r%#tuplearg0)*#stride, (c%#tuplearg1)*#stride};";
}
(*it)->process_recursive(stream, PARENT_NODE_TYPE, accessors);
}
@@ -98,7 +103,7 @@ std::string mreduction::generate_impl(unsigned int label, symbolic_expressions_c
for (unsigned int a = 0; a < simd_width; ++a)
{
std::map<std::string, std::string> accessors;
accessors["array"] = str[a];
accessors["array2"] = str[a];
accessors["repeat"] = "#namereg";
accessors["scalar"] = "#namereg";
std::string value = exprs[k]->evaluate_recursive(LHS_NODE_TYPE, accessors);
@@ -151,7 +156,7 @@ std::string mreduction::generate_impl(unsigned int label, symbolic_expressions_c
stream.inc_tab();
std::map<std::string, std::string> accessors;
accessors["mreduction"] = "#name_buf[lid0*" + lsize1str + "]";
accessors["array"] = "#pointer[r*#stride1]";
accessors["array1"] = "#pointer[r*#stride]";
evaluate(stream, PARENT_NODE_TYPE, accessors, symbolic_expressions, mappings);
stream.dec_tab();
stream << "}" << std::endl;

16
lib/backend/templates/reduction.cpp
View File

@@ -92,7 +92,7 @@ std::string reduction::generate_impl(unsigned int label, char type, symbolic_exp
stream << "unsigned int lid = get_local_id(0);" << std::endl;
process(stream, PARENT_NODE_TYPE, tools::make_map<std::map<std::string, std::string> >("scalar", "#scalartype #namereg = *#pointer;")
("array", "#pointer += #start1;"), symbolic_expressions, mappings);
("array1", "#pointer += #start;"), symbolic_expressions, mappings);
for (unsigned int k = 0; k < N; ++k)
{
@@ -117,13 +117,13 @@ std::string reduction::generate_impl(unsigned int label, char type, symbolic_exp
void operator()(kernel_generation_stream & stream, unsigned int simd_width) const
{
std::string i = (simd_width==1)?"i*#stride1":"i";
std::string i = (simd_width==1)?"i*#stride":"i";
//Fetch vector entry
for (std::vector<mapped_scalar_reduction*>::const_iterator it = exprs.begin(); it != exprs.end(); ++it)
(*it)->process_recursive(stream, PARENT_NODE_TYPE, tools::make_map<std::map<std::string, std::string> >("array", append_width("#scalartype",simd_width) + " #namereg = " + vload(simd_width,i,"#pointer")+";")
("matrix_row", "#scalartype #namereg = #pointer[$OFFSET{#row*#stride1, i*#stride2}];")
("matrix_column", "#scalartype #namereg = #pointer[$OFFSET{i*#stride1,#column*#stride2}];")
("matrix_diag", "#scalartype #namereg = #pointer[#diag_offset<0?$OFFSET{(i - #diag_offset)*#stride1, i*#stride2}:$OFFSET{i*#stride1, (i + #diag_offset)*#stride2}];"));
(*it)->process_recursive(stream, PARENT_NODE_TYPE, tools::make_map<std::map<std::string, std::string> >("array1", append_width("#scalartype",simd_width) + " #namereg = " + vload(simd_width,i,"#pointer")+";")
("matrix_row", "#scalartype #namereg = #pointer[$OFFSET{#row*#stride, i*#stride2}];")
("matrix_column", "#scalartype #namereg = #pointer[$OFFSET{i*#stride,#column*#stride2}];")
("matrix_diag", "#scalartype #namereg = #pointer[#diag_offset<0?$OFFSET{(i - #diag_offset)*#stride, i*#stride2}:$OFFSET{i*#stride, (i + #diag_offset)*#stride2}];"));
//Update accumulators
@@ -139,7 +139,7 @@ std::string reduction::generate_impl(unsigned int label, char type, symbolic_exp
for (unsigned int a = 0; a < simd_width; ++a)
{
std::map<std::string, std::string> accessors;
accessors["array"] = str[a];
accessors["array1"] = str[a];
accessors["matrix_row"] = str[a];
accessors["matrix_column"] = str[a];
accessors["matrix_diag"] = str[a];
@@ -243,7 +243,7 @@ std::string reduction::generate_impl(unsigned int label, char type, symbolic_exp
std::map<std::string, std::string> accessors;
accessors["scalar_reduction"] = "#name_buf[0]";
accessors["scalar"] = "*#pointer";
accessors["array"] = "#pointer[#start1]";
accessors["array1"] = "#pointer[#start]";
evaluate(stream, PARENT_NODE_TYPE, accessors, symbolic_expressions, mappings);
stream.dec_tab();
stream << "}" << std::endl;

10
lib/backend/templates/vaxpy.cpp
View File

@@ -40,8 +40,8 @@ std::vector<std::string> vaxpy::generate_impl(unsigned int label, symbolic_expre
process(stream, PARENT_NODE_TYPE,
tools::make_map<std::map<std::string, std::string> >("scalar", "#scalartype #namereg = *#pointer;")
("array", "#pointer += #start1 + #start2*#ld;")
("array", "#start1/=" + str_simd_width + ";"), symbolic_expressions, mappings);
("array1", "#pointer += #start;")
("array1", "#start1/=" + str_simd_width + ";"), symbolic_expressions, mappings);
std::string init, upper_bound, inc;
fetching_loop_info(p_.fetching_policy, "N/"+str_simd_width, stream, init, upper_bound, inc, "get_global_id(0)", "get_global_size(0)");
@@ -49,19 +49,19 @@ std::vector<std::string> vaxpy::generate_impl(unsigned int label, symbolic_expre
stream << "{" << std::endl;
stream.inc_tab();
process(stream, PARENT_NODE_TYPE,
tools::make_map<std::map<std::string, std::string> >("array", data_type + " #namereg = #pointer[i*#stride1];")
tools::make_map<std::map<std::string, std::string> >("array1", data_type + " #namereg = #pointer[i*#stride];")
("matrix_row", "#scalartype #namereg = $VALUE{#row*#stride1, i*#stride2};")
("matrix_column", "#scalartype #namereg = $VALUE{i*#stride1,#column*#stride2};")
("matrix_diag", "#scalartype #namereg = #pointer[#diag_offset<0?$OFFSET{(i - #diag_offset)*#stride1, i*#stride2}:$OFFSET{i*#stride1, (i + #diag_offset)*#stride2}];")
, symbolic_expressions, mappings);
evaluate(stream, PARENT_NODE_TYPE, tools::make_map<std::map<std::string, std::string> >("array", "#namereg")
evaluate(stream, PARENT_NODE_TYPE, tools::make_map<std::map<std::string, std::string> >("array1", "#namereg")
("matrix_row", "#namereg")
("matrix_column", "#namereg")
("matrix_diag", "#namereg")
("scalar", "#namereg"), symbolic_expressions, mappings);
process(stream, LHS_NODE_TYPE, tools::make_map<std::map<std::string, std::string> >("array", "#pointer[i*#stride1] = #namereg;")
process(stream, LHS_NODE_TYPE, tools::make_map<std::map<std::string, std::string> >("array1", "#pointer[i*#stride] = #namereg;")
("matrix_row", "$VALUE{#row, i} = #namereg;")
("matrix_column", "$VALUE{i, #column} = #namereg;")
("matrix_diag", "#diag_offset<0?$VALUE{(i - #diag_offset)*#stride1, i*#stride2}:$VALUE{i*#stride1, (i + #diag_offset)*#stride2} = #namereg;")

2
tests/common.hpp
View File

@@ -154,7 +154,9 @@ bool failure_vector(VecType1 const & x, VecType2 const & y, typename VecType1::v
if(std::max(x[i], y[i])!=0)
delta/=std::abs(std::max(x[i], y[i]));
if(delta > epsilon)
{
return true;
}
}
return false;
}

72
tests/maxpy.cpp
View File

@@ -43,46 +43,46 @@ void test(T epsilon, simple_matrix_base<T> & cA, simple_matrix_base<T>& cB, simp
std::cout << std::endl;\
}
RUN_TEST("C = A", cC(i,j) = cA(i,j), C = A)
RUN_TEST("C = A + B", cC(i,j) = cA(i,j) + cB(i,j), C = A + B)
RUN_TEST("C = A - B", cC(i,j) = cA(i,j) - cB(i,j), C = A - B)
RUN_TEST("C = A + B + C", cC(i,j) = cA(i,j) + cB(i,j) + cC(i,j), C = A + B + C)
// RUN_TEST("C = A", cC(i,j) = cA(i,j), C = A)
// RUN_TEST("C = A + B", cC(i,j) = cA(i,j) + cB(i,j), C = A + B)
// RUN_TEST("C = A - B", cC(i,j) = cA(i,j) - cB(i,j), C = A - B)
// RUN_TEST("C = A + B + C", cC(i,j) = cA(i,j) + cB(i,j) + cC(i,j), C = A + B + C)
RUN_TEST("C = a*A", cC(i,j) = aa*cA(i,j), C = a*A)
RUN_TEST("C = da*A", cC(i,j) = aa*cA(i,j), C = da*A)
RUN_TEST("C = a*A + b*B", cC(i,j) = aa*cA(i,j) + bb*cB(i,j), C= a*A + b*B)
RUN_TEST("C = da*A + b*B", cC(i,j) = aa*cA(i,j) + bb*cB(i,j), C= da*A + b*B)
RUN_TEST("C = a*A + db*B", cC(i,j) = aa*cA(i,j) + bb*cB(i,j), C= a*A + db*B)
RUN_TEST("C = da*A + db*B", cC(i,j) = aa*cA(i,j) + bb*cB(i,j), C= da*A + db*B)
// RUN_TEST("C = a*A", cC(i,j) = aa*cA(i,j), C = a*A)
// RUN_TEST("C = da*A", cC(i,j) = aa*cA(i,j), C = da*A)
// RUN_TEST("C = a*A + b*B", cC(i,j) = aa*cA(i,j) + bb*cB(i,j), C= a*A + b*B)
// RUN_TEST("C = da*A + b*B", cC(i,j) = aa*cA(i,j) + bb*cB(i,j), C= da*A + b*B)
// RUN_TEST("C = a*A + db*B", cC(i,j) = aa*cA(i,j) + bb*cB(i,j), C= a*A + db*B)
// RUN_TEST("C = da*A + db*B", cC(i,j) = aa*cA(i,j) + bb*cB(i,j), C= da*A + db*B)
RUN_TEST("C = exp(A)", cC(i,j) = exp(cA(i,j)), C= exp(A))
RUN_TEST("C = abs(A)", cC(i,j) = abs(cA(i,j)), C= abs(A))
RUN_TEST("C = acos(A)", cC(i,j) = acos(cA(i,j)), C= acos(A))
RUN_TEST("C = asin(A)", cC(i,j) = asin(cA(i,j)), C= asin(A))
RUN_TEST("C = atan(A)", cC(i,j) = atan(cA(i,j)), C= atan(A))
RUN_TEST("C = ceil(A)", cC(i,j) = ceil(cA(i,j)), C= ceil(A))
RUN_TEST("C = cos(A)", cC(i,j) = cos(cA(i,j)), C= cos(A))
RUN_TEST("C = cosh(A)", cC(i,j) = cosh(cA(i,j)), C= cosh(A))
RUN_TEST("C = floor(A)", cC(i,j) = floor(cA(i,j)), C= floor(A))
RUN_TEST("C = log(A)", cC(i,j) = log(cA(i,j)), C= log(A))
RUN_TEST("C = log10(A)", cC(i,j) = log10(cA(i,j)), C= log10(A))
RUN_TEST("C = sin(A)", cC(i,j) = sin(cA(i,j)), C= sin(A))
RUN_TEST("C = sinh(A)", cC(i,j) = sinh(cA(i,j)), C= sinh(A))
RUN_TEST("C = sqrt(A)", cC(i,j) = sqrt(cA(i,j)), C= sqrt(A))
RUN_TEST("C = tan(A)", cC(i,j) = tan(cA(i,j)), C= tan(A))
RUN_TEST("C = tanh(A)", cC(i,j) = tanh(cA(i,j)), C= tanh(A))
// RUN_TEST("C = exp(A)", cC(i,j) = exp(cA(i,j)), C= exp(A))
// RUN_TEST("C = abs(A)", cC(i,j) = abs(cA(i,j)), C= abs(A))
// RUN_TEST("C = acos(A)", cC(i,j) = acos(cA(i,j)), C= acos(A))
// RUN_TEST("C = asin(A)", cC(i,j) = asin(cA(i,j)), C= asin(A))
// RUN_TEST("C = atan(A)", cC(i,j) = atan(cA(i,j)), C= atan(A))
// RUN_TEST("C = ceil(A)", cC(i,j) = ceil(cA(i,j)), C= ceil(A))
// RUN_TEST("C = cos(A)", cC(i,j) = cos(cA(i,j)), C= cos(A))
// RUN_TEST("C = cosh(A)", cC(i,j) = cosh(cA(i,j)), C= cosh(A))
// RUN_TEST("C = floor(A)", cC(i,j) = floor(cA(i,j)), C= floor(A))
// RUN_TEST("C = log(A)", cC(i,j) = log(cA(i,j)), C= log(A))
// RUN_TEST("C = log10(A)", cC(i,j) = log10(cA(i,j)), C= log10(A))
// RUN_TEST("C = sin(A)", cC(i,j) = sin(cA(i,j)), C= sin(A))
// RUN_TEST("C = sinh(A)", cC(i,j) = sinh(cA(i,j)), C= sinh(A))
// RUN_TEST("C = sqrt(A)", cC(i,j) = sqrt(cA(i,j)), C= sqrt(A))
// RUN_TEST("C = tan(A)", cC(i,j) = tan(cA(i,j)), C= tan(A))
// RUN_TEST("C = tanh(A)", cC(i,j) = tanh(cA(i,j)), C= tanh(A))
RUN_TEST("C = A.*B", cC(i,j) = cA(i,j)*cB(i,j), C= A*B)
RUN_TEST("C = A./B", cC(i,j) = cA(i,j)/cB(i,j), C= A/B)
RUN_TEST("C = A==B", cC(i,j) = cA(i,j)==cB(i,j), C= A==B)
RUN_TEST("C = A>=B", cC(i,j) = cA(i,j)>=cB(i,j), C= A>=B)
RUN_TEST("C = A>B", cC(i,j) = cA(i,j)>cB(i,j), C= A>B)
RUN_TEST("C = A<=B", cC(i,j) = cA(i,j)<=cB(i,j), C= A<=B)
RUN_TEST("C = A<B", cC(i,j) = cA(i,j)<cB(i,j), C= A<B)
RUN_TEST("C = A!=B", cC(i,j) = cA(i,j)!=cB(i,j), C= A!=B)
RUN_TEST("C = pow(A,B)", cC(i,j) = pow(cA(i,j), cB(i,j)), C= pow(A,B))
// RUN_TEST("C = A.*B", cC(i,j) = cA(i,j)*cB(i,j), C= A*B)
// RUN_TEST("C = A./B", cC(i,j) = cA(i,j)/cB(i,j), C= A/B)
// RUN_TEST("C = A==B", cC(i,j) = cA(i,j)==cB(i,j), C= A==B)
// RUN_TEST("C = A>=B", cC(i,j) = cA(i,j)>=cB(i,j), C= A>=B)
// RUN_TEST("C = A>B", cC(i,j) = cA(i,j)>cB(i,j), C= A>B)
// RUN_TEST("C = A<=B", cC(i,j) = cA(i,j)<=cB(i,j), C= A<=B)
// RUN_TEST("C = A<B", cC(i,j) = cA(i,j)<cB(i,j), C= A<B)
// RUN_TEST("C = A!=B", cC(i,j) = cA(i,j)!=cB(i,j), C= A!=B)
// RUN_TEST("C = pow(A,B)", cC(i,j) = pow(cA(i,j), cB(i,j)), C= pow(A,B))
RUN_TEST("C = eye(M, N)", cC(i,j) = i==j, C= eye(M, N, C.dtype()))
// RUN_TEST("C = eye(M, N)", cC(i,j) = i==j, C= eye(M, N, C.dtype()))
RUN_TEST("C = outer(x, y)", cC(i,j) = cx[i]*cy[j], C= outer(x,y))
#undef RUN_TEST

2
tests/mproduct.cpp
View File

@@ -68,7 +68,7 @@ void test_impl(T epsilon)
INIT_MATRIX(K, SUBK, 9, 4, N, SUBN, 6, 2, cB, B);
std::cout << "full..." << std::endl;
test_impl(epsilon, cC_matrix, cA_matrix, cB_matrix, C_matrix, A_matrix, AT_matrix, B_matrix, BT_matrix);
test_impl(epsilon, cC_full, cA_full, cB_full, C_full, A_full, AT_full, B_full, BT_full);
std::cout << "slice..." << std::endl;
test_impl(epsilon, cC_slice, cA_slice, cB_slice, C_slice, A_slice, AT_slice, B_slice, BT_slice);
}

19
tests/mreduction.cpp
View File

@@ -10,13 +10,15 @@ void test_row_wise_reduction(T epsilon, simple_vector_base<T> & cy, simple_matri
{
int failure_count = 0;
ad::int_t M = A.shape()._1;
ad::int_t N = A.shape()._2;
simple_vector<T> buffer(M);
simple_vector<T> bufy(M);
simple_vector<T> bufx(N);
T yi = 0, xi = 0;
#define TEST_OPERATION(NAME, SIZE1, SIZE2, REDUCTION, ASSIGNMENT, GPU_REDUCTION)\
#define TEST_OPERATION(NAME, SIZE1, SIZE2, REDUCTION, ASSIGNMENT, GPU_REDUCTION, RES, BUF, CRES)\
std::cout << NAME "..." << std::flush;\
for(int i = 0 ; i < SIZE1 ; ++i)\
{\
@@ -27,8 +29,8 @@ void test_row_wise_reduction(T epsilon, simple_vector_base<T> & cy, simple_matri
ASSIGNMENT;\
}\
GPU_REDUCTION;\
ad::copy(y, buffer.data());\
if(failure_vector(cy, buffer, epsilon))\
ad::copy(RES, BUF.data());\
if(failure_vector(CRES, BUF, epsilon))\
{\
failure_count++;\
std::cout << " [Failure!]" << std::endl;\
@@ -36,8 +38,8 @@ void test_row_wise_reduction(T epsilon, simple_vector_base<T> & cy, simple_matri
else\
std::cout << std::endl;
TEST_OPERATION("y = A.x", M, N, yi+=cA(i,j)*cx[j], cy[i] = yi, y = dot(A,x));
TEST_OPERATION("x = A'.y", N, M, xi+=cA(j, i)*cy[j], cx[i] = xi, x = dot(trans(A),y));
TEST_OPERATION("y = A.x", M, N, yi+=cA(i,j)*cx[j], cy[i] = yi, y = dot(A,x), y, bufy, cy);
TEST_OPERATION("x = A'.y", N, M, xi+=cA(j,i)*cy[j], cx[i] = xi, x = dot(trans(A),y), x, bufx, cx);
if(failure_count>0)
exit(EXIT_FAILURE);
@@ -55,7 +57,10 @@ void test_impl(T epsilon)
INIT_VECTOR(M, SUBM, 6, 2, cy, y);
INIT_VECTOR(N, SUBN, 4, 3, cx, x);
test_row_wise_reduction(epsilon, cy_vector, cA_matrix, cx_vector, y_vector, A_matrix, x_vector);
// std::cout << "full..." << std::endl;
// test_row_wise_reduction(epsilon, cy_full, cA_full, cx_full, y_full, A_full, x_full);
std::cout << "slice..." << std::endl;
test_row_wise_reduction(epsilon, cy_slice, cA_slice, cx_slice, y_slice, A_slice, x_slice);
}
int main()

10
tests/reduction.cpp
View File

@@ -62,14 +62,14 @@ void test_impl(T epsilon)
INIT_VECTOR(N, SUBN, 2, 4, cx, x);
INIT_VECTOR(N, SUBN, 5, 8, cy, y);
#define TEST_OPERATIONS(XTYPE, YTYPE)\
test_reduction(epsilon, cx_ ## XTYPE, cy_ ## YTYPE,\
x_ ## XTYPE, y_ ## YTYPE);\
#define TEST_OPERATIONS(TYPE)\
test_reduction(epsilon, cx_ ## TYPE, cy_ ## TYPE,\
x_ ## TYPE, y_ ## TYPE);\
std::cout << "> standard..." << std::endl;
TEST_OPERATIONS(vector, vector);
TEST_OPERATIONS(full);
std::cout << "> slice..." << std::endl;
TEST_OPERATIONS(slice, slice);
TEST_OPERATIONS(slice);
}
int main()

10
tests/vaxpy.cpp
View File

@@ -97,14 +97,14 @@ void test_impl(T epsilon)
INIT_VECTOR(N, SUBN, 3, 2, cz, z);
#define TEST_OPERATIONS(XTYPE, YTYPE, ZTYPE)\
test_element_wise_vector(epsilon, cx_ ## XTYPE, cy_ ## YTYPE, cz_ ## ZTYPE,\
x_ ## XTYPE, y_ ## YTYPE, z_ ## ZTYPE);\
#define TEST_OPERATIONS(TYPE)\
test_element_wise_vector(epsilon, cx_ ## TYPE, cy_ ## TYPE, cz_ ## TYPE,\
x_ ## TYPE, y_ ## TYPE, z_ ## TYPE);\
std::cout << "> standard..." << std::endl;
TEST_OPERATIONS(vector, vector, vector);
TEST_OPERATIONS(full);
std::cout << "> slice..." << std::endl;
TEST_OPERATIONS(slice, slice, slice);
TEST_OPERATIONS(slice);
}
int main()