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

Bench: restored benchmarks

Browse Source
This commit is contained in:
Philippe Tillet
2016-11-20 23:28:39 -05:00
parent 54b5b7523d
commit 9f821c01bc
7 changed files with 9 additions and 93 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
bench/blas.cpp
View File

@@ -304,7 +304,7 @@ void bench(sc::numeric_type dtype, std::string operation)
void handle_misusage(){
std::cerr << "Usage : blas-bench [--dtype {float32, float64}] [--device DEVICE_IDX] [--help]" << std::endl;
// std::cerr << "--op: operation to benchmark" << std::endl;
std::cerr << "--op: operation to benchmark" << std::endl;
std::cerr << "--dtype: data-type to benchmark" << std::endl;
std::cerr << "--device: index of isaac device in [0, ..., ndevices - 1]" << std::endl;
std::cerr << "--help: display this message" << std::endl;
@@ -341,7 +341,7 @@ int main(int argc, char* argv[])
if(std::find(args.begin(), args.end(), "--help") != args.end())
handle_misusage();
std::string operation = "gemm";
std::string operation = getopt(args, "--op", {"axpy", "dot", "gemv", "gemm"}, "gemm");
std::string dtype = getopt(args, "--dtype", {"float32", "float64"}, "float32");
int device;
try{

BIN
build/bench/bench-blas
View File

Binary file not shown.

22
include/isaac/array.h
View File

@@ -106,7 +106,6 @@ public:
array_base& operator/=(expression_tree const &);
//Indexing (1D)
expression_tree operator[](placeholder idx) const;
const scalar operator[](int_t) const;
scalar operator[](int_t);
view operator[](slice const &);
@@ -208,22 +207,14 @@ template<class T> ISAACAPI void copy(array_base const & gA, std::vector<T> & cA,
#define ISAAC_DECLARE_ELEMENT_BINARY_OPERATOR(OPNAME) \
ISAACAPI expression_tree OPNAME (array_base const & x, expression_tree const & y);\
ISAACAPI expression_tree OPNAME (array_base const & x, value_scalar const & y);\
ISAACAPI expression_tree OPNAME (array_base const & x, placeholder const & y);\
ISAACAPI expression_tree OPNAME (array_base const & x, array_base const & y);\
\
ISAACAPI expression_tree OPNAME (expression_tree const & x, expression_tree const & y);\
ISAACAPI expression_tree OPNAME (expression_tree const & x, value_scalar const & y);\
ISAACAPI expression_tree OPNAME (expression_tree const & x, placeholder const & y);\
ISAACAPI expression_tree OPNAME (expression_tree const & x, array_base const & y);\
\
ISAACAPI expression_tree OPNAME (value_scalar const & y, expression_tree const & x);\
ISAACAPI expression_tree OPNAME (value_scalar const & y, placeholder const & x);\
ISAACAPI expression_tree OPNAME (value_scalar const & y, array_base const & x);\
\
ISAACAPI expression_tree OPNAME (placeholder const & y, expression_tree const & x);\
ISAACAPI expression_tree OPNAME (placeholder const & y, placeholder const & x);\
ISAACAPI expression_tree OPNAME (placeholder const & y, value_scalar const & x);\
ISAACAPI expression_tree OPNAME (placeholder const & y, array_base const & x);
ISAAC_DECLARE_ELEMENT_BINARY_OPERATOR(operator +)
ISAAC_DECLARE_ELEMENT_BINARY_OPERATOR(operator -)
@@ -321,19 +312,6 @@ ISAACAPI expression_tree mean(expression_tree const &, int_t axis = -1);
//Fusion
ISAACAPI expression_tree fuse(expression_tree const & x, expression_tree const & y);
//For
ISAACAPI expression_tree sfor(expression_tree const & start, expression_tree const & end, expression_tree const & inc, expression_tree const & expression);
static const placeholder _i0{0};
static const placeholder _i1{1};
static const placeholder _i2{2};
static const placeholder _i3{3};
static const placeholder _i4{4};
static const placeholder _i5{5};
static const placeholder _i6{6};
static const placeholder _i7{7};
static const placeholder _i8{8};
static const placeholder _i9{9};
//Initializers
ISAACAPI expression_tree eye(int_t, int_t, isaac::numeric_type, driver::Context const & context = driver::backend::contexts::get_default());
ISAACAPI expression_tree zeros(tuple const & shape, numeric_type dtype, driver::Context const & context = driver::backend::contexts::get_default());

19
include/isaac/jit/syntax/expression/expression.h
View File

@@ -46,19 +46,6 @@ namespace isaac
class array_base;
struct placeholder
{
expression_tree operator=(value_scalar const & ) const;
expression_tree operator=(expression_tree const & ) const;
expression_tree operator+=(value_scalar const & ) const;
expression_tree operator-=(value_scalar const & ) const;
expression_tree operator*=(value_scalar const & ) const;
expression_tree operator/=(value_scalar const & ) const;
int level;
};
struct invalid_node{};
enum node_type
@@ -67,7 +54,6 @@ enum node_type
COMPOSITE_OPERATOR_TYPE,
VALUE_SCALAR_TYPE,
DENSE_ARRAY_TYPE,
PLACEHOLDER_TYPE
};
union handle_t
@@ -92,7 +78,6 @@ public:
//Constructors
node();
node(invalid_node);
node(placeholder x);
node(value_scalar const & x);
node(array_base const & x);
node(int_t lhs, op_element op, int_t rhs, numeric_type dtype, tuple const & shape);
@@ -116,8 +101,6 @@ public:
values_holder scalar;
//Array
array_holder array;
//Placeholder
placeholder ph;
};
};
@@ -134,7 +117,7 @@ public:
data_type const & data() const;
std::size_t root() const;
driver::Context const & context() const;
numeric_type dtype() const;
numeric_type const & dtype() const;
node const & operator[](size_t) const;
node & operator[](size_t);

41
lib/array.cpp
View File

@@ -164,8 +164,7 @@ array_base & array_base::operator=(array_base const & rhs)
{
if(min(shape_)==0) return *this;
assert(dtype_ == rhs.dtype());
expression_tree expression(*this, rhs, op_element(BINARY_ARITHMETIC, ASSIGN_TYPE), &context_, dtype_, shape_);
runtime::execute(expression);
runtime::execute(assign(*this, rhs));
return *this;
}
@@ -173,8 +172,7 @@ array_base & array_base::operator=(value_scalar const & rhs)
{
if(min(shape_)==0) return *this;
assert(dtype_ == rhs.dtype());
expression_tree expression(*this, rhs, op_element(BINARY_ARITHMETIC, ASSIGN_TYPE), &context_, dtype_, shape_);
runtime::execute(expression);
runtime::execute(assign(*this, rhs));
return *this;
}
@@ -183,8 +181,7 @@ array_base& array_base::operator=(runtime::execution_handler const & c)
{
if(min(shape_)==0) return *this;
assert(dtype_ == c.x().dtype());
expression_tree expression(*this, c.x(), op_element(BINARY_ARITHMETIC, ASSIGN_TYPE), &context_, dtype_, shape_);
runtime::execute(runtime::execution_handler(expression, c.execution_options(), c.dispatcher_options(), c.compilation_options()));
runtime::execute(runtime::execution_handler(assign(*this, c.x()), c.execution_options(), c.dispatcher_options(), c.compilation_options()));
return *this;
}
@@ -267,11 +264,6 @@ array_base & array_base::operator/=(expression_tree const & rhs)
/*--- Indexing operators -----*/
//---------------------------------------
expression_tree array_base::operator[](placeholder idx) const
{
return expression_tree(*this, idx, op_element(BINARY_ARITHMETIC, ACCESS_INDEX_TYPE), &context_, dtype_, {1});
}
scalar array_base::operator [](int_t idx)
{
assert(dim()<=1);
@@ -534,10 +526,6 @@ expression_tree OPNAME (array_base const & x, array_base const & y) \
expression_tree OPNAME (array_base const & x, value_scalar const & y) \
{ return expression_tree(x, y, op_element(BINARY_ARITHMETIC, OP), &x.context(), DTYPE, x.shape()); }\
\
expression_tree OPNAME (array_base const & x, placeholder const & y) \
{ return expression_tree(x, y, op_element(BINARY_ARITHMETIC, OP), &x.context(), DTYPE, x.shape()); }\
\
\
expression_tree OPNAME (expression_tree const & x, expression_tree const & y) \
{ return broadcast(x, y, op_element(BINARY_ARITHMETIC, OP), DTYPE); } \
\
@@ -547,9 +535,6 @@ expression_tree OPNAME (expression_tree const & x, array_base const & y) \
expression_tree OPNAME (expression_tree const & x, value_scalar const & y) \
{ return expression_tree(x, y, op_element(BINARY_ARITHMETIC, OP), &x.context(), DTYPE, x.shape()); } \
\
expression_tree OPNAME (expression_tree const & x, placeholder const & y) \
{ return expression_tree(x, y, op_element(BINARY_ARITHMETIC, OP), &x.context(), DTYPE, x.shape()); } \
\
\
expression_tree OPNAME (value_scalar const & y, expression_tree const & x) \
{ return expression_tree(y, x, op_element(BINARY_ARITHMETIC, OP), &x.context(), DTYPE, x.shape()); } \
@@ -557,22 +542,6 @@ expression_tree OPNAME (value_scalar const & y, expression_tree const & x) \
expression_tree OPNAME (value_scalar const & y, array_base const & x) \
{ return expression_tree(y, x, op_element(BINARY_ARITHMETIC, OP), &x.context(), DTYPE, x.shape()); }\
\
expression_tree OPNAME (value_scalar const & x, placeholder const & y) \
{ return expression_tree(x, y, op_element(BINARY_ARITHMETIC, OP), NULL, DTYPE, {1}); }\
\
\
expression_tree OPNAME (placeholder const & y, expression_tree const & x) \
{ return expression_tree(y, x, op_element(BINARY_ARITHMETIC, OP), &x.context(), DTYPE, x.shape()); } \
\
expression_tree OPNAME (placeholder const & y, value_scalar const & x) \
{ return expression_tree(y, x, op_element(BINARY_ARITHMETIC, OP), NULL, DTYPE, {1}); } \
\
expression_tree OPNAME (placeholder const & y, array_base const & x) \
{ return expression_tree(y, x, op_element(BINARY_ARITHMETIC, OP), &x.context(), DTYPE, x.shape()); }\
\
expression_tree OPNAME (placeholder const & y, placeholder const & x) \
{ return expression_tree(y, x, op_element(BINARY_ARITHMETIC, OP), NULL, INVALID_NUMERIC_TYPE, {1}); }
DEFINE_ELEMENT_BINARY_OPERATOR(ADD_TYPE, operator +, x.dtype())
DEFINE_ELEMENT_BINARY_OPERATOR(SUB_TYPE, operator -, x.dtype())
@@ -583,7 +552,7 @@ DEFINE_ELEMENT_BINARY_OPERATOR(ELEMENT_MAX_TYPE, maximum, x.dtype())
DEFINE_ELEMENT_BINARY_OPERATOR(ELEMENT_MIN_TYPE, minimum, x.dtype())
DEFINE_ELEMENT_BINARY_OPERATOR(ELEMENT_POW_TYPE, pow, x.dtype())
DEFINE_ELEMENT_BINARY_OPERATOR(ASSIGN_TYPE, assign, x.dtype())
DEFINE_ELEMENT_BINARY_OPERATOR(ASSIGN_TYPE, assign, y.dtype())
DEFINE_ELEMENT_BINARY_OPERATOR(ELEMENT_GREATER_TYPE, operator >, INT_TYPE)
@@ -841,7 +810,7 @@ namespace detail
{
int_t M = A.shape()[0];
int_t N = A.shape()[1];
expression_tree::node & A_root = (expression_tree::node &)A[A.root()];
expression_tree::node A_root = (expression_tree::node &)A[A.root()];
bool A_trans = A_root.binary_operator.op.type==TRANS_TYPE;
while(A_root.type==COMPOSITE_OPERATOR_TYPE){
A_root = A[A_root.binary_operator.lhs];

2
lib/jit/syntax/engine/process.cpp
View File

@@ -185,8 +185,6 @@ symbols_table symbolize(isaac::expression_tree const & tree)
bool is_assigned = std::find(assignee.begin(), assignee.end(), root)!=assignee.end();
table.insert({root, make_symbolic<buffer>(context, dtype, binder->get(node.array.handle, is_assigned), node.shape, node.ld)});
}
else if(node.type==PLACEHOLDER_TYPE)
table.insert({root, make_symbolic<placeholder>(context, node.ph.level)});
else if(node.type==COMPOSITE_OPERATOR_TYPE)
{
unsigned int id = binder->get();

14
lib/jit/syntax/expression/expression.cpp
View File

@@ -38,9 +38,6 @@ expression_tree::node::node(){}
expression_tree::node::node(invalid_node) : type(INVALID_SUBTYPE), dtype(INVALID_NUMERIC_TYPE)
{}
expression_tree::node::node(placeholder x) : type(PLACEHOLDER_TYPE), dtype(INVALID_NUMERIC_TYPE), shape{1}, ph(x)
{}
expression_tree::node::node(value_scalar const & x) : type(VALUE_SCALAR_TYPE), dtype(x.dtype()), shape{1}, scalar(x.values())
{}
@@ -116,7 +113,7 @@ std::size_t expression_tree::root() const
driver::Context const & expression_tree::context() const
{ return *context_; }
numeric_type expression_tree::dtype() const
numeric_type const & expression_tree::dtype() const
{ return tree_[root_].dtype; }
tuple expression_tree::shape() const
@@ -137,15 +134,6 @@ expression_tree::node const & expression_tree::operator[](size_t idx) const
expression_tree::node & expression_tree::operator[](size_t idx)
{ return tree_[idx]; }
//
expression_tree placeholder::operator=(value_scalar const & r) const { return expression_tree(*this, r, op_element(BINARY_ARITHMETIC,ASSIGN_TYPE), NULL, r.dtype(), {1}); }
expression_tree placeholder::operator=(expression_tree const & r) const { return expression_tree(*this, r, op_element(BINARY_ARITHMETIC,ASSIGN_TYPE), &r.context(), r.dtype(), r.shape()); }
expression_tree placeholder::operator+=(value_scalar const & r) const { return *this = *this + r; }
expression_tree placeholder::operator-=(value_scalar const & r) const { return *this = *this - r; }
expression_tree placeholder::operator*=(value_scalar const & r) const { return *this = *this * r; }
expression_tree placeholder::operator/=(value_scalar const & r) const { return *this = *this / r; }
//io
#define ISAAC_MAP_TO_STRING(NAME) case NAME: return #NAME