exceptions.hpp

// Copyright (c) 2015 Graphcore Ltd. All rights reserved.
 
#ifndef poplar_exceptions_hpp
#define poplar_exceptions_hpp
 
#include <poplar/DebugContext.hpp>
#include <poplar/Error.hpp>
 
#include <iosfwd>
#include <stdexcept>
#include <string>
 
namespace poplar {
 
struct poplar_error : std::runtime_error {
private:
  std::string msg;
 
public:
  std::string type;
  explicit poplar_error(const std::string &s);
  explicit poplar_error(const char *s);
 
  // Internal use only
  void attachSourceLocation(const DebugContext &context);
 
  const char *what() const noexcept override;
  ~poplar_error() override;
};
 
struct graph_program_compilation_error : poplar_error {
  explicit graph_program_compilation_error(const std::string &s);
  explicit graph_program_compilation_error(const char *s);
  ~graph_program_compilation_error() override;
};
 
struct graph_object_creation_error : poplar_error {
  explicit graph_object_creation_error(const std::string &s);
  explicit graph_object_creation_error(const char *s);
  ~graph_object_creation_error() override;
};
 
struct graph_object_load_error : poplar_error {
  explicit graph_object_load_error(const std::string &path,
                                   const std::string &error);
  ~graph_object_load_error() override;
};
 
struct no_environment : poplar_error {
  explicit no_environment(const std::string &s);
  explicit no_environment(const char *s);
  ~no_environment() override;
};
 
struct unknown_vertex_type : poplar_error {
  explicit unknown_vertex_type(const std::string &name);
  ~unknown_vertex_type() override;
};
 
struct unknown_field : poplar_error {
  explicit unknown_field(const std::string &s);
  explicit unknown_field(const char *s);
  unknown_field(const std::string &fieldName,
                const std::string &vertexTypeName);
  ~unknown_field() override;
};
 
struct control_program_error : poplar_error {
  explicit control_program_error(const std::string &msg);
  ~control_program_error() override;
};
 
struct type_error : poplar_error {
  explicit type_error(const std::string &s);
  explicit type_error(const char *s);
  ~type_error() override;
};
 
struct index_error : poplar_error {
  explicit index_error(const std::string &s);
  explicit index_error(const char *s);
  index_error(const std::string &vertexDotField, std::size_t index);
  ~index_error() override;
};
 
struct no_size_specified : poplar_error {
  explicit no_size_specified(const std::string &s);
  explicit no_size_specified(const char *s);
  no_size_specified(const std::string &fieldName,
                    const std::string &vertexName);
  ~no_size_specified() override;
};
 
struct graph_connection_error : poplar_error {
  explicit graph_connection_error(const std::string &s);
  explicit graph_connection_error(const char *s);
  ~graph_connection_error() override;
};
 
struct graph_cycle_error : poplar_error {
  explicit graph_cycle_error(const std::string &s);
  explicit graph_cycle_error(const char *s);
  ~graph_cycle_error() override;
};
 
struct graph_recursion_error : poplar_error {
  explicit graph_recursion_error(const std::string &s);
  explicit graph_recursion_error(const char *s);
  ~graph_recursion_error() override;
};
 
struct graph_replication_error : poplar_error {
  explicit graph_replication_error(const std::string &s);
  explicit graph_replication_error(const char *s);
  ~graph_replication_error() override;
};
 
struct profiling_disabled : poplar_error {
  profiling_disabled();
  ~profiling_disabled() override;
};
 
struct missing_graph_profile : poplar_error {
  explicit missing_graph_profile(const std::string &s);
  explicit missing_graph_profile(const char *s);
  ~missing_graph_profile() override;
};
 
struct missing_perf_estimate : poplar_error {
  explicit missing_perf_estimate(const std::string &vertexName);
  ~missing_perf_estimate() override;
};
 
struct invalid_tile_mapping : poplar_error {
  explicit invalid_tile_mapping(const std::string &s);
  explicit invalid_tile_mapping(const char *s);
  ~invalid_tile_mapping() override;
};
 
struct tensor_creation_error : poplar_error {
  explicit tensor_creation_error(const std::string &s);
  explicit tensor_creation_error(const char *s);
  ~tensor_creation_error() override;
};
 
struct tensor_io_state_error : poplar_error {
  explicit tensor_io_state_error(const std::string &s);
  explicit tensor_io_state_error(const char *s);
  ~tensor_io_state_error() override;
};
 
struct tensor_metadata_error : poplar_error {
  explicit tensor_metadata_error(const std::string &s);
  explicit tensor_metadata_error(const char *s);
  ~tensor_metadata_error() override;
};
 
struct stream_connection_error : poplar_error {
  explicit stream_connection_error(const std::string &s);
  explicit stream_connection_error(const char *s);
  ~stream_connection_error() override;
};
 
struct overflow_error : poplar_error {
  explicit overflow_error(const std::string &s);
  explicit overflow_error(const char *s);
  ~overflow_error() override;
};
 
struct memory_elem_constraints_error : poplar_error {
  explicit memory_elem_constraints_error(const std::string &s);
  explicit memory_elem_constraints_error(const char *s);
  ~memory_elem_constraints_error() override;
};
 
struct graph_memory_allocation_error : poplar_error {
 
  std::string profilePath;
 
  explicit graph_memory_allocation_error(const std::string &s);
  explicit graph_memory_allocation_error(const char *s);
  ~graph_memory_allocation_error() override;
};
 
struct stream_memory_allocation_error : poplar_error {
  explicit stream_memory_allocation_error(const std::string &s);
  explicit stream_memory_allocation_error(const char *s);
  ~stream_memory_allocation_error() override;
};
 
struct invalid_machine_model : poplar_error {
  explicit invalid_machine_model(const std::string &s);
  explicit invalid_machine_model(const char *s);
  ~invalid_machine_model() override;
};
 
struct invalid_option : poplar_error {
  explicit invalid_option(const std::string &s);
  explicit invalid_option(const char *s);
  ~invalid_option() override;
};
 
struct link_error : poplar_error {
  std::string output;
  explicit link_error(const std::string &s, const std::string &out = "");
  explicit link_error(const char *s, const char *out = "");
  ~link_error() override;
};
 
struct runtime_error : poplar_error {
  struct ErrorInfo {
    ErrorCode code;
    ErrorLocation location;
    bool isSimulated;
  };
 
  std::vector<ErrorInfo> errors;
 
  explicit runtime_error(const std::string &s);
  explicit runtime_error(const char *s);
  ~runtime_error() override;
};
 
struct application_runtime_error : runtime_error {
  explicit application_runtime_error(const std::string &s);
  explicit application_runtime_error(const char *s);
  ~application_runtime_error() override;
};
 
struct system_runtime_error : runtime_error {
  explicit system_runtime_error(const std::string &s);
  explicit system_runtime_error(const char *s);
  ~system_runtime_error() override;
};
 
enum class RecoveryAction {
  IPU_RESET,
  PARTITION_RESET,
  FULL_RESET
};
 
std::string toString(RecoveryAction recoveryAction);
 
std::ostream &operator<<(std::ostream &os, RecoveryAction recoveryAction);
 
struct recoverable_runtime_error : system_runtime_error {
private:
  RecoveryAction recoveryAction;
 
public:
  RecoveryAction getRecoveryAction() const { return recoveryAction; }
  explicit recoverable_runtime_error(RecoveryAction recoveryAction,
                                     const std::string &s);
  explicit recoverable_runtime_error(RecoveryAction recoveryAction,
                                     const char *s);
  ~recoverable_runtime_error() override;
};
 
struct unrecoverable_runtime_error : system_runtime_error {
  explicit unrecoverable_runtime_error(const std::string &s);
  explicit unrecoverable_runtime_error(const char *s);
  ~unrecoverable_runtime_error() override;
};
 
struct unknown_runtime_error : system_runtime_error {
  explicit unknown_runtime_error(const std::string &s);
  explicit unknown_runtime_error(const char *s);
  ~unknown_runtime_error() override;
};
 
struct symbol_error : poplar_error {
  explicit symbol_error(const std::string &name, const unsigned tile);
  ~symbol_error() override;
};
 
struct file_load_error : poplar_error {
  explicit file_load_error(const std::string &path);
  ~file_load_error() override;
};
 
struct parse_error : poplar_error {
  explicit parse_error(const std::string &s);
  explicit parse_error(const char *s);
  ~parse_error() override;
};
} // End namespace poplar.
 
#endif // poplar_exceptions_hpp