ViennaCL - The Vienna Computing Library  1.5.2
viennacl/scheduler/io.hpp
Go to the documentation of this file.
00001 #ifndef VIENNACL_SCHEDULER_IO_HPP
00002 #define VIENNACL_SCHEDULER_IO_HPP
00003 
00004 /* =========================================================================
00005    Copyright (c) 2010-2014, Institute for Microelectronics,
00006                             Institute for Analysis and Scientific Computing,
00007                             TU Wien.
00008    Portions of this software are copyright by UChicago Argonne, LLC.
00009 
00010                             -----------------
00011                   ViennaCL - The Vienna Computing Library
00012                             -----------------
00013 
00014    Project Head:    Karl Rupp                   rupp@iue.tuwien.ac.at
00015 
00016    (A list of authors and contributors can be found in the PDF manual)
00017 
00018    License:         MIT (X11), see file LICENSE in the base directory
00019 ============================================================================= */
00020 
00021 
00026 #include <iostream>
00027 #include <sstream>
00028 
00029 #include "viennacl/forwards.h"
00030 #include "viennacl/scheduler/forwards.h"
00031 
00032 
00033 namespace viennacl
00034 {
00035   namespace scheduler
00036   {
00037 
00038     namespace detail
00039     {
00040 #define VIENNACL_TRANSLATE_OP_TO_STRING(NAME)   case NAME: return #NAME;
00041 
00043       std::string to_string(viennacl::scheduler::op_element op_elem)
00044       {
00045         if (op_elem.type_family == OPERATION_UNARY_TYPE_FAMILY)
00046         {
00047           switch (op_elem.type)
00048           {
00049             VIENNACL_TRANSLATE_OP_TO_STRING(OPERATION_UNARY_ABS_TYPE)
00050             VIENNACL_TRANSLATE_OP_TO_STRING(OPERATION_UNARY_ACOS_TYPE)
00051             VIENNACL_TRANSLATE_OP_TO_STRING(OPERATION_UNARY_ASIN_TYPE)
00052             VIENNACL_TRANSLATE_OP_TO_STRING(OPERATION_UNARY_ATAN_TYPE)
00053             VIENNACL_TRANSLATE_OP_TO_STRING(OPERATION_UNARY_CEIL_TYPE)
00054             VIENNACL_TRANSLATE_OP_TO_STRING(OPERATION_UNARY_COS_TYPE)
00055             VIENNACL_TRANSLATE_OP_TO_STRING(OPERATION_UNARY_COSH_TYPE)
00056             VIENNACL_TRANSLATE_OP_TO_STRING(OPERATION_UNARY_EXP_TYPE)
00057             VIENNACL_TRANSLATE_OP_TO_STRING(OPERATION_UNARY_FABS_TYPE)
00058             VIENNACL_TRANSLATE_OP_TO_STRING(OPERATION_UNARY_FLOOR_TYPE)
00059             VIENNACL_TRANSLATE_OP_TO_STRING(OPERATION_UNARY_LOG_TYPE)
00060             VIENNACL_TRANSLATE_OP_TO_STRING(OPERATION_UNARY_LOG10_TYPE)
00061             VIENNACL_TRANSLATE_OP_TO_STRING(OPERATION_UNARY_SIN_TYPE)
00062             VIENNACL_TRANSLATE_OP_TO_STRING(OPERATION_UNARY_SINH_TYPE)
00063             VIENNACL_TRANSLATE_OP_TO_STRING(OPERATION_UNARY_SQRT_TYPE)
00064             VIENNACL_TRANSLATE_OP_TO_STRING(OPERATION_UNARY_TAN_TYPE)
00065             VIENNACL_TRANSLATE_OP_TO_STRING(OPERATION_UNARY_TANH_TYPE)
00066             VIENNACL_TRANSLATE_OP_TO_STRING(OPERATION_UNARY_TRANS_TYPE)
00067             VIENNACL_TRANSLATE_OP_TO_STRING(OPERATION_UNARY_NORM_1_TYPE)
00068             VIENNACL_TRANSLATE_OP_TO_STRING(OPERATION_UNARY_NORM_2_TYPE)
00069             VIENNACL_TRANSLATE_OP_TO_STRING(OPERATION_UNARY_NORM_INF_TYPE)
00070 
00071             default: throw statement_not_supported_exception("Cannot convert unary operation to string");
00072           }
00073         }
00074         else if (op_elem.type_family == OPERATION_BINARY_TYPE_FAMILY)
00075         {
00076           switch (op_elem.type)
00077           {
00078             VIENNACL_TRANSLATE_OP_TO_STRING(OPERATION_BINARY_ASSIGN_TYPE)
00079             VIENNACL_TRANSLATE_OP_TO_STRING(OPERATION_BINARY_INPLACE_ADD_TYPE)
00080             VIENNACL_TRANSLATE_OP_TO_STRING(OPERATION_BINARY_INPLACE_SUB_TYPE)
00081             VIENNACL_TRANSLATE_OP_TO_STRING(OPERATION_BINARY_ADD_TYPE)
00082             VIENNACL_TRANSLATE_OP_TO_STRING(OPERATION_BINARY_SUB_TYPE)
00083             VIENNACL_TRANSLATE_OP_TO_STRING(OPERATION_BINARY_MAT_VEC_PROD_TYPE)
00084             VIENNACL_TRANSLATE_OP_TO_STRING(OPERATION_BINARY_MAT_MAT_PROD_TYPE)
00085             VIENNACL_TRANSLATE_OP_TO_STRING(OPERATION_BINARY_MULT_TYPE)
00086             VIENNACL_TRANSLATE_OP_TO_STRING(OPERATION_BINARY_DIV_TYPE)
00087             VIENNACL_TRANSLATE_OP_TO_STRING(OPERATION_BINARY_ELEMENT_PROD_TYPE)
00088             VIENNACL_TRANSLATE_OP_TO_STRING(OPERATION_BINARY_ELEMENT_DIV_TYPE)
00089             VIENNACL_TRANSLATE_OP_TO_STRING(OPERATION_BINARY_INNER_PROD_TYPE)
00090 
00091             default: throw statement_not_supported_exception("Cannot convert unary operation to string");
00092           }
00093         }
00094         else if (op_elem.type_family == OPERATION_INVALID_TYPE_FAMILY)
00095         {
00096           if (op_elem.type == OPERATION_INVALID_TYPE)
00097             return "OPERATION_INVALID_TYPE";
00098           else
00099             throw statement_not_supported_exception("Unknown invalid operation type when converting to string");
00100         }
00101         else
00102           throw statement_not_supported_exception("Unknown operation family when converting to string");
00103       }
00104 
00105 #undef VIENNACL_TRANSLATE_OP_TO_STRING
00106 
00107 #define VIENNACL_TRANSLATE_ELEMENT_TO_STRING(NAME, ELEMENT)   case NAME: ss << "(" << element.ELEMENT << ")"; return #NAME + ss.str();
00108 
00110       std::string to_string(viennacl::scheduler::lhs_rhs_element element)
00111       {
00112         std::stringstream ss;
00113 
00114         if (element.type_family == COMPOSITE_OPERATION_FAMILY)
00115         {
00116           ss << "(" << element.node_index << ")";
00117           return "COMPOSITE_OPERATION_FAMILY" + ss.str();
00118         }
00119         else if (element.type_family == SCALAR_TYPE_FAMILY)
00120         {
00121           if (element.subtype == HOST_SCALAR_TYPE)
00122           {
00123             ss << ", HOST_SCALAR_TYPE ";
00124             switch (element.numeric_type)
00125             {
00126               VIENNACL_TRANSLATE_ELEMENT_TO_STRING(CHAR_TYPE,   host_char)
00127               VIENNACL_TRANSLATE_ELEMENT_TO_STRING(UCHAR_TYPE,  host_uchar)
00128               VIENNACL_TRANSLATE_ELEMENT_TO_STRING(SHORT_TYPE,  host_short)
00129               VIENNACL_TRANSLATE_ELEMENT_TO_STRING(USHORT_TYPE, host_ushort)
00130               VIENNACL_TRANSLATE_ELEMENT_TO_STRING(INT_TYPE,    host_int)
00131               VIENNACL_TRANSLATE_ELEMENT_TO_STRING(UINT_TYPE,   host_uint)
00132               VIENNACL_TRANSLATE_ELEMENT_TO_STRING(LONG_TYPE,   host_long)
00133               VIENNACL_TRANSLATE_ELEMENT_TO_STRING(ULONG_TYPE,  host_ulong)
00134               VIENNACL_TRANSLATE_ELEMENT_TO_STRING(FLOAT_TYPE,  host_float)
00135               VIENNACL_TRANSLATE_ELEMENT_TO_STRING(DOUBLE_TYPE, host_double)
00136 
00137               default: throw statement_not_supported_exception("Cannot convert host scalar type to string");
00138             }
00139           }
00140           else
00141           {
00142             ss << ", DEVICE_SCALAR_TYPE";
00143             switch (element.numeric_type)
00144             {
00145               //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(CHAR_TYPE,   scalar_char)
00146               //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(UCHAR_TYPE,  scalar_uchar)
00147               //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(SHORT_TYPE,  scalar_short)
00148               //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(USHORT_TYPE, scalar_ushort)
00149               //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(INT_TYPE,    scalar_int)
00150               //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(UINT_TYPE,   scalar_uint)
00151               //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(LONG_TYPE,   scalar_long)
00152               //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(ULONG_TYPE,  scalar_ulong)
00153               //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(HALF_TYPE,   scalar_half)
00154               VIENNACL_TRANSLATE_ELEMENT_TO_STRING(FLOAT_TYPE,  scalar_float)
00155               VIENNACL_TRANSLATE_ELEMENT_TO_STRING(DOUBLE_TYPE, scalar_double)
00156             default: throw statement_not_supported_exception("Cannot convert scalar type to string");
00157             }
00158           }
00159         }
00160         else if (element.type_family == VECTOR_TYPE_FAMILY)
00161         {
00162           ss << ", DENSE_VECTOR_TYPE ";
00163           switch (element.numeric_type)
00164           {
00165             //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(CHAR_TYPE,   vector_char)
00166             //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(UCHAR_TYPE,  vector_uchar)
00167             //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(SHORT_TYPE,  vector_short)
00168             //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(USHORT_TYPE, vector_ushort)
00169             //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(INT_TYPE,    vector_int)
00170             //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(UINT_TYPE,   vector_uint)
00171             //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(LONG_TYPE,   vector_long)
00172             //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(ULONG_TYPE,  vector_ulong)
00173             //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(HALF_TYPE,   vector_half)
00174             VIENNACL_TRANSLATE_ELEMENT_TO_STRING(FLOAT_TYPE,  vector_float)
00175             VIENNACL_TRANSLATE_ELEMENT_TO_STRING(DOUBLE_TYPE, vector_double)
00176 
00177             default: throw statement_not_supported_exception("Cannot convert vector type to string");
00178           }
00179         }
00180         else if (element.type_family == MATRIX_TYPE_FAMILY)
00181         {
00182           if (element.subtype == DENSE_ROW_MATRIX_TYPE)
00183           {
00184             ss << ", DENSE_ROW_MATRIX_TYPE ";
00185             switch (element.numeric_type)
00186             {
00187               //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(CHAR_TYPE,   matrix_row_char)
00188               //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(UCHAR_TYPE,  matrix_row_uchar)
00189               //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(SHORT_TYPE,  matrix_row_short)
00190               //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(USHORT_TYPE, matrix_row_ushort)
00191               //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(INT_TYPE,    matrix_row_int)
00192               //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(UINT_TYPE,   matrix_row_uint)
00193               //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(LONG_TYPE,   matrix_row_long)
00194               //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(ULONG_TYPE,  matrix_row_ulong)
00195               //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(HALF_TYPE,   matrix_row_half)
00196               VIENNACL_TRANSLATE_ELEMENT_TO_STRING(FLOAT_TYPE,  matrix_row_float)
00197               VIENNACL_TRANSLATE_ELEMENT_TO_STRING(DOUBLE_TYPE, matrix_row_double)
00198 
00199               default: throw statement_not_supported_exception("Cannot convert row-major matrix type to string");
00200             }
00201           }
00202           else
00203           {
00204             ss << ", DENSE_COL_MATRIX_TYPE ";
00205             switch (element.numeric_type)
00206             {
00207               //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(CHAR_TYPE,   matrix_col_char)
00208               //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(UCHAR_TYPE,  matrix_col_uchar)
00209               //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(SHORT_TYPE,  matrix_col_short)
00210               //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(USHORT_TYPE, matrix_col_ushort)
00211               //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(INT_TYPE,    matrix_col_int)
00212               //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(UINT_TYPE,   matrix_col_uint)
00213               //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(LONG_TYPE,   matrix_col_long)
00214               //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(ULONG_TYPE,  matrix_col_ulong)
00215               //VIENNACL_TRANSLATE_ELEMENT_TO_STRING(HALF_TYPE,   matrix_col_half)
00216               VIENNACL_TRANSLATE_ELEMENT_TO_STRING(FLOAT_TYPE,  matrix_col_float)
00217               VIENNACL_TRANSLATE_ELEMENT_TO_STRING(DOUBLE_TYPE, matrix_col_double)
00218 
00219               default: throw statement_not_supported_exception("Cannot convert column-major matrix type to string");
00220             }
00221           }
00222         }
00223         else if (element.type_family == INVALID_TYPE_FAMILY)
00224         {
00225           return "INVALID_TYPE_FAMILY";
00226         }
00227         else
00228           throw statement_not_supported_exception("Unknown operation family when converting to string");
00229       }
00230 
00231 #undef VIENNACL_TRANSLATE_ELEMENT_TO_STRING
00232 
00233     } // namespace detail
00234 
00235 
00237     std::ostream & operator<<(std::ostream & os, viennacl::scheduler::statement_node const & s_node)
00238     {
00239       os << "LHS: " << detail::to_string(s_node.lhs) << ", "
00240          << "OP: "  << detail::to_string(s_node.op) << ", "
00241          << "RHS: " << detail::to_string(s_node.rhs);
00242 
00243       return os;
00244     }
00245 
00246 
00247 
00248 
00249 
00250     namespace detail
00251     {
00253       void print_node(std::ostream & os, viennacl::scheduler::statement const & s, vcl_size_t node_index, vcl_size_t indent = 0)
00254       {
00255         typedef viennacl::scheduler::statement::container_type   StatementNodeContainer;
00256         typedef viennacl::scheduler::statement::value_type       StatementNode;
00257 
00258         StatementNodeContainer const & nodes = s.array();
00259         StatementNode const & current_node = nodes[node_index];
00260 
00261         for (vcl_size_t i=0; i<indent; ++i)
00262           os << " ";
00263 
00264         os << "Node " << node_index << ": " << current_node << std::endl;
00265 
00266         if (current_node.lhs.type_family == COMPOSITE_OPERATION_FAMILY)
00267           print_node(os, s, current_node.lhs.node_index, indent+1);
00268 
00269         if (current_node.rhs.type_family == COMPOSITE_OPERATION_FAMILY)
00270           print_node(os, s, current_node.rhs.node_index, indent+1);
00271       }
00272     }
00273 
00280     std::ostream & operator<<(std::ostream & os, viennacl::scheduler::statement const & s)
00281     {
00282       detail::print_node(os, s, s.root());
00283       return os;
00284     }
00285   }
00286 
00287 } //namespace viennacl
00288 
00289 #endif
00290