/var/lib/jenkins/jobs/Skylark/workspace/base/exception.hpp

Go to the documentation of this file.

#ifndef SKYLARK_EXCEPTION_HPP
#define SKYLARK_EXCEPTION_HPP

#include <string>
#include <exception>

#include <boost/exception/all.hpp>

const char* const skylark_errmsg[] = {
      "Skylark failure"
    , "Skylark failed while communicating (MPI)"
    , "Skylark failed in a call to Elemental"
    , "Skylark failed due to a unsupported matrix distribution"
    , "Skylark failed in a call to CombBLAS"
    , "Skylark failed in sketching a matrix"
    , "Skylark failed in nla operation"
    , "Skylark failed when allocating memory in a sketch"
    , "Skylark failed in a call into the Random123 layer"
    , "Skylark failed in I/O calls"
    , "Skylark failed due to a unsupported base operation"
};

const char* skylark_strerror(int error_code) {
    return skylark_errmsg[error_code - 100];
}


#define SKYLARK_BEGIN_TRY() try {

#define SKYLARK_END_TRY()   }

#define SKYLARK_THROW_EXCEPTION(x) \
    BOOST_THROW_EXCEPTION(x);

#define SKYLARK_PRINT_EXCEPTION_DETAILS(ex) \
    std::cerr << boost::diagnostic_information(ex) << std::endl;

#define SKYLARK_PRINT_EXCEPTION_TRACE(ex) \
    if (const std::string *trace = \
            boost::get_error_info<skylark::base::stack_trace>(ex)) { \
        std::cerr << *trace << std::endl; \
    }

//XXX: only get top-most exception?
#define SKYLARK_CATCH_AND_RETURN_ERROR_CODE() \
    catch (const skylark::base::skylark_exception& ex) { \
        if (int const *c = \
                boost::get_error_info<skylark::base::error_code>(ex)) { \
            return *c; \
        } \
    }



namespace skylark {
namespace base {

typedef boost::error_info<struct tag_error_code, int>         error_code;
typedef boost::error_info<struct tag_error_msg,  std::string> error_msg;

typedef boost::error_info<struct tag_stack_trace,  std::string> stack_trace;
typedef boost::error_info<struct tag_append_trace, std::string> append_trace;

struct skylark_exception : virtual boost::exception, virtual std::exception {

    skylark_exception() {
        *this << error_code(100);
    }

    skylark_exception& operator<< (const append_trace& rhs) {

        std::string trace_value = "";

        if( const std::string *cur_trace =
            boost::get_error_info<stack_trace, skylark_exception>(*this) ) {
            trace_value.append(*cur_trace);
            trace_value.append("\n");
        }

        trace_value.append(rhs.value());
        *this << stack_trace(trace_value);
        return *this;
    }

};

struct elemental_exception : virtual skylark_exception {
public:
    using skylark_exception::operator<<;

    elemental_exception() {
        *this << error_code(102);
    }
};
struct combblas_exception : virtual skylark_exception {
public:
    using skylark_exception::operator<<;

    combblas_exception() {
        *this << error_code(104);
    }
};
struct mpi_exception : virtual skylark_exception {
public:
    using skylark_exception::operator<<;

    mpi_exception() {
        *this << error_code(101);
    }
};

struct sketch_exception : virtual skylark_exception {
public:
    using skylark_exception::operator<<;

    sketch_exception() {
        *this << error_code(105);
    }
};

struct nla_exception : virtual skylark_exception {
public:
    using skylark_exception::operator<<;

    nla_exception() {
        *this << error_code(106);
    }
};


struct random123_exception : virtual skylark_exception {
public:
    using skylark_exception::operator<<;

    random123_exception() {
        *this << error_code(108);
    }
};

struct io_exception : virtual skylark_exception {
public:
    using skylark_exception::operator<<;

    io_exception() {
        *this << error_code(108);
    }
};

struct allocation_exception : virtual sketch_exception  {
public:
    using sketch_exception::operator<<;

    allocation_exception() {
        *this << error_code(107);
    }
};

struct unsupported_matrix_distribution : virtual elemental_exception {
public:
    using elemental_exception::operator<<;

    unsupported_matrix_distribution() {
        *this << error_code(103);
    }
};

struct unsupported_base_operation : virtual elemental_exception {
public:
    using skylark_exception::operator<<;

    unsupported_base_operation() {
        *this << error_code(109);
    }
};


} // namespace base
} // namespace skylark

#endif