exception.hpp

// SPDX-FileCopyrightText: 2017 - 2024 The Ginkgo authors
//
// SPDX-License-Identifier: BSD-3-Clause
 
#ifndef GKO_PUBLIC_CORE_BASE_EXCEPTION_HPP_
#define GKO_PUBLIC_CORE_BASE_EXCEPTION_HPP_
 
 
#include <exception>
#include <string>
 
 
#include <ginkgo/core/base/types.hpp>
 
 
namespace gko {
 
 
class Error : public std::exception {
public:
    Error(const std::string& file, int line, const std::string& what)
        : what_(file + ":" + std::to_string(line) + ": " + what)
    {}
 
    virtual const char* what() const noexcept override { return what_.c_str(); }
 
private:
    const std::string what_;
};
 
 
class NotImplemented : public Error {
public:
    NotImplemented(const std::string& file, int line, const std::string& func)
        : Error(file, line, func + " is not implemented")
    {}
};
 
 
class NotCompiled : public Error {
public:
    NotCompiled(const std::string& file, int line, const std::string& func,
                const std::string& module)
        : Error(file, line,
                "feature " + func + " is part of the " + module +
                    " module, which is not compiled on this system")
    {}
};
 
 
class NotSupported : public Error {
public:
    NotSupported(const std::string& file, int line, const std::string& func,
                 const std::string& obj_type)
        : Error(file, line,
                "Operation " + func + " does not support parameters of type " +
                    obj_type)
    {}
};
 
 
class MpiError : public Error {
public:
    MpiError(const std::string& file, int line, const std::string& func,
             int64 error_code)
        : Error(file, line, func + ": " + get_error(error_code))
    {}
 
private:
    static std::string get_error(int64 error_code);
};
 
 
class CudaError : public Error {
public:
    CudaError(const std::string& file, int line, const std::string& func,
              int64 error_code)
        : Error(file, line, func + ": " + get_error(error_code))
    {}
 
private:
    static std::string get_error(int64 error_code);
};
 
 
class CublasError : public Error {
public:
    CublasError(const std::string& file, int line, const std::string& func,
                int64 error_code)
        : Error(file, line, func + ": " + get_error(error_code))
    {}
 
private:
    static std::string get_error(int64 error_code);
};
 
 
class CurandError : public Error {
public:
    CurandError(const std::string& file, int line, const std::string& func,
                int64 error_code)
        : Error(file, line, func + ": " + get_error(error_code))
    {}
 
private:
    static std::string get_error(int64 error_code);
};
 
 
class CusparseError : public Error {
public:
    CusparseError(const std::string& file, int line, const std::string& func,
                  int64 error_code)
        : Error(file, line, func + ": " + get_error(error_code))
    {}
 
private:
    static std::string get_error(int64 error_code);
};
 
 
class CufftError : public Error {
public:
    CufftError(const std::string& file, int line, const std::string& func,
               int64 error_code)
        : Error(file, line, func + ": " + get_error(error_code))
    {}
 
private:
    static std::string get_error(int64 error_code);
};
 
 
class HipError : public Error {
public:
    HipError(const std::string& file, int line, const std::string& func,
             int64 error_code)
        : Error(file, line, func + ": " + get_error(error_code))
    {}
 
private:
    static std::string get_error(int64 error_code);
};
 
 
class HipblasError : public Error {
public:
    HipblasError(const std::string& file, int line, const std::string& func,
                 int64 error_code)
        : Error(file, line, func + ": " + get_error(error_code))
    {}
 
private:
    static std::string get_error(int64 error_code);
};
 
 
class HiprandError : public Error {
public:
    HiprandError(const std::string& file, int line, const std::string& func,
                 int64 error_code)
        : Error(file, line, func + ": " + get_error(error_code))
    {}
 
private:
    static std::string get_error(int64 error_code);
};
 
 
class HipsparseError : public Error {
public:
    HipsparseError(const std::string& file, int line, const std::string& func,
                   int64 error_code)
        : Error(file, line, func + ": " + get_error(error_code))
    {}
 
private:
    static std::string get_error(int64 error_code);
};
 
 
class HipfftError : public Error {
public:
    HipfftError(const std::string& file, int line, const std::string& func,
                int64 error_code)
        : Error(file, line, func + ": " + get_error(error_code))
    {}
 
private:
    static std::string get_error(int64 error_code);
};
 
 
class MetisError : public Error {
public:
    MetisError(const std::string& file, int line, const std::string& func,
               const std::string& error)
        : Error(file, line, func + ": " + error)
    {}
};
 
 
class DimensionMismatch : public Error {
public:
    DimensionMismatch(const std::string& file, int line,
                      const std::string& func, const std::string& first_name,
                      size_type first_rows, size_type first_cols,
                      const std::string& second_name, size_type second_rows,
                      size_type second_cols, const std::string& clarification)
        : Error(file, line,
                func + ": attempting to combine operators " + first_name +
                    " [" + std::to_string(first_rows) + " x " +
                    std::to_string(first_cols) + "] and " + second_name + " [" +
                    std::to_string(second_rows) + " x " +
                    std::to_string(second_cols) + "]: " + clarification)
    {}
};
 
 
class BadDimension : public Error {
public:
    BadDimension(const std::string& file, int line, const std::string& func,
                 const std::string& op_name, size_type op_num_rows,
                 size_type op_num_cols, const std::string& clarification)
        : Error(file, line,
                func + ": Object " + op_name + " has dimensions [" +
                    std::to_string(op_num_rows) + " x " +
                    std::to_string(op_num_cols) + "]: " + clarification)
    {}
};
 
 
template <typename IndexType>
class BlockSizeError : public Error {
public:
    BlockSizeError(const std::string& file, const int line,
                   const int block_size, const IndexType size)
        : Error(file, line,
                "block size = " + std::to_string(block_size) +
                    ", size = " + std::to_string(size))
    {}
};
 
 
class ValueMismatch : public Error {
public:
    ValueMismatch(const std::string& file, int line, const std::string& func,
                  size_type val1, size_type val2,
                  const std::string& clarification)
        : Error(file, line,
                func + ": Value mismatch : " + std::to_string(val1) + " and " +
                    std::to_string(val2) + " : " + clarification)
    {}
};
 
 
class AllocationError : public Error {
public:
    AllocationError(const std::string& file, int line,
                    const std::string& device, size_type bytes)
        : Error(file, line,
                device + ": failed to allocate memory block of " +
                    std::to_string(bytes) + "B")
    {}
};
 
 
class OutOfBoundsError : public Error {
public:
    OutOfBoundsError(const std::string& file, int line, size_type index,
                     size_type bound)
        : Error(file, line,
                "trying to access index " + std::to_string(index) +
                    " in a memory block of " + std::to_string(bound) +
                    " elements")
    {}
};
 
 
class OverflowError : public Error {
public:
    OverflowError(const std::string& file, const int line,
                  const std::string& index_type)
        : Error(file, line, "Overflowing " + index_type)
    {}
};
 
 
class StreamError : public Error {
public:
    StreamError(const std::string& file, int line, const std::string& func,
                const std::string& message)
        : Error(file, line, func + ": " + message)
    {}
};
 
 
class KernelNotFound : public Error {
public:
    KernelNotFound(const std::string& file, int line, const std::string& func)
        : Error(file, line, func + ": unable to find an eligible kernel")
    {}
};
 
 
class UnsupportedMatrixProperty : public Error {
public:
    UnsupportedMatrixProperty(const std::string& file, const int line,
                              const std::string& msg)
        : Error(file, line, msg)
    {}
};
 
 
class InvalidStateError : public Error {
public:
    InvalidStateError(const std::string& file, int line,
                      const std::string& func, const std::string& clarification)
        : Error(file, line,
                func + ": Invalid state encountered : " + clarification)
    {}
};
 
 
}  // namespace gko
 
 
#endif  // GKO_PUBLIC_CORE_BASE_EXCEPTION_HPP_