Revert D34868005: [torch::deploy] remove asserts from deploy

Test Plan: revert-hammer

Differential Revision:
D34868005 (pytorch@48b1654)

Original commit changeset: c8bb1f7a2b16

Original Phabricator Diff: D34868005 (pytorch@48b1654)

fbshipit-source-id: a9f2250880f44b2ebe09a44f955dd8568a203b1b
(cherry picked from commit c0537d6)

Author: malfet

torch/csrc/deploy/Exception.h

@@ -1,3 +1,4 @@
+#include <c10/util/Exception.h>
 #include <torch/csrc/deploy/deploy.h>
 #include <torch/csrc/deploy/elf_file.h>
 #include <torch/cuda.h>
@@ -45,7 +46,7 @@ const std::initializer_list<InterpreterSymbol> kInterpreterSearchPath = {
 };
 
 static bool writeDeployInterpreter(FILE* dst) {
-  MULTIPY_INTERNAL_ASSERT(dst);
+  TORCH_INTERNAL_ASSERT(dst);
   const char* payloadStart = nullptr;
   size_t size = 0;
   bool customLoader = false;
@@ -82,7 +83,7 @@ static bool writeDeployInterpreter(FILE* dst) {
     payloadStart = libStart;
   }
   size_t written = fwrite(payloadStart, 1, size, dst);
-  MULTIPY_INTERNAL_ASSERT(size == written, "expected written == size");
+  TORCH_INTERNAL_ASSERT(size == written, "expected written == size");
   return customLoader;
 }
 
@@ -213,9 +214,9 @@ using dlopen_t = void* (*)(const char*, int);
 // function.
 static dlopen_t find_real_dlopen() {
   void* libc = dlopen("libdl.so.2", RTLD_NOLOAD | RTLD_LAZY | RTLD_LOCAL);
-  MULTIPY_INTERNAL_ASSERT(libc);
+  TORCH_INTERNAL_ASSERT(libc);
   auto dlopen_ = (dlopen_t)dlsym(libc, "dlopen");
-  MULTIPY_INTERNAL_ASSERT(dlopen_);
+  TORCH_INTERNAL_ASSERT(dlopen_);
   return dlopen_;
 }
 
@@ -226,7 +227,7 @@ Interpreter::Interpreter(
   // NOLINTNEXTLINE(modernize-avoid-c-arrays,cppcoreguidelines-avoid-c-arrays)
   char libraryName[] = "/tmp/torch_deployXXXXXX";
   int fd = mkstemp(libraryName);
-  MULTIPY_INTERNAL_ASSERT(fd != -1, "failed to create temporary file");
+  TORCH_INTERNAL_ASSERT(fd != -1, "failed to create temporary file");
   libraryName_ = libraryName;
   FILE* dst = fdopen(fd, "wb");
 
@@ -342,12 +343,12 @@ void PythonMethodWrapper::setArgumentNames(
     return;
   }
 
-  MULTIPY_INTERNAL_ASSERT(iArgumentNames.isList());
+  TORCH_INTERNAL_ASSERT(iArgumentNames.isList());
   auto argumentNames = iArgumentNames.toListRef();
 
   argumentNamesOut.reserve(argumentNames.size());
   for (auto& argumentName : argumentNames) {
-    MULTIPY_INTERNAL_ASSERT(argumentName.isString());
+    TORCH_INTERNAL_ASSERT(argumentName.isString());
     argumentNamesOut.push_back(argumentName.toStringRef());
   }
 }

torch/csrc/deploy/deploy.cpp

@@ -1,5 +1,6 @@
 #pragma once
 #include <c10/util/Optional.h>
+#include <c10/util/irange.h>
 #include <torch/csrc/api/include/torch/imethod.h>
 #include <torch/csrc/deploy/interpreter/interpreter_impl.h>
 #include <torch/csrc/deploy/noop_environment.h>

torch/csrc/deploy/deploy.h

@@ -1,6 +1,5 @@
-#include <torch/csrc/deploy/Exception.h>
-#include <torch/csrc/deploy/elf_file.h>
 #include <c10/util/irange.h>
+#include <torch/csrc/deploy/elf_file.h>
 
 namespace torch {
 namespace deploy {
@@ -14,7 +13,7 @@ ElfFile::ElfFile(const char* filename) : memFile_(filename) {
   shdrList_ = (Elf64_Shdr*)(fileData + ehdr_->e_shoff);
 
   auto strtabSecNo = ehdr_->e_shstrndx;
-  MULTIPY_CHECK(
+  TORCH_CHECK(
       strtabSecNo >= 0 && strtabSecNo < numSections_,
       "e_shstrndx out of range");
 
@@ -27,7 +26,7 @@ ElfFile::ElfFile(const char* filename) : memFile_(filename) {
 }
 
 at::optional<Section> ElfFile::findSection(const char* name) const {
-  MULTIPY_CHECK(name != nullptr, "Null name");
+  TORCH_CHECK(name != nullptr, "Null name");
   at::optional<Section> found = at::nullopt;
   for (const auto& section : sections_) {
     if (strcmp(name, section.name) == 0) {
@@ -41,13 +40,13 @@ at::optional<Section> ElfFile::findSection(const char* name) const {
 
 void ElfFile::checkFormat() const {
   // check the magic numbers
-  MULTIPY_CHECK(
+  TORCH_CHECK(
       (ehdr_->e_ident[EI_MAG0] == ELFMAG0) &&
           (ehdr_->e_ident[EI_MAG1] == ELFMAG1) &&
           (ehdr_->e_ident[EI_MAG2] == ELFMAG2) &&
           (ehdr_->e_ident[EI_MAG3] == ELFMAG3),
       "Unexpected magic numbers");
-  MULTIPY_CHECK(
+  TORCH_CHECK(
       ehdr_->e_ident[EI_CLASS] == ELFCLASS64, "Only support 64bit ELF file");
 }
 

torch/csrc/deploy/elf_file.cpp

@@ -2,7 +2,6 @@
 
 #include <c10/util/Optional.h>
 #include <elf.h>
-#include <torch/csrc/deploy/Exception.h>
 #include <torch/csrc/deploy/mem_file.h>
 #include <vector>
 
@@ -41,15 +40,15 @@ class ElfFile {
     const char* name = "";
 
     if (strtabSection_) {
-      MULTIPY_CHECK(nameOff >= 0 && nameOff < strtabSection_.len, "");
+      TORCH_CHECK(nameOff >= 0 && nameOff < strtabSection_.len);
       name = strtabSection_.start + nameOff;
     }
     const char* start = memFile_.data() + shOff;
     return Section{name, start, len};
   }
 
   [[nodiscard]] const char* str(size_t off) const {
-    MULTIPY_CHECK(off < strtabSection_.len, "String table index out of range");
+    TORCH_CHECK(off < strtabSection_.len, "String table index out of range");
     return strtabSection_.start + off;
   }
   void checkFormat() const;

torch/csrc/deploy/elf_file.h

@@ -2,6 +2,8 @@
 
 #include <ATen/ATen.h>
 #include <ATen/TypeDefault.h>
+#include <c10/util/irange.h>
+
 #include <torch/script.h>
 
 #include <pthread.h>

torch/csrc/deploy/example/benchmark.cpp

@@ -1,6 +1,6 @@
 #include <Python.h>
+#include <c10/util/Exception.h>
 #include <fmt/format.h>
-#include <torch/csrc/deploy/Exception.h>
 #include <torch/csrc/deploy/interpreter/builtin_registry.h>
 
 namespace torch {
@@ -55,10 +55,10 @@ BuiltinRegistry* BuiltinRegistry::get() {
 }
 
 void BuiltinRegistry::runPreInitialization() {
-  MULTIPY_INTERNAL_ASSERT(!Py_IsInitialized());
+  TORCH_INTERNAL_ASSERT(!Py_IsInitialized());
   sanityCheck();
   PyImport_FrozenModules = BuiltinRegistry::getAllFrozenModules();
-  MULTIPY_INTERNAL_ASSERT(PyImport_FrozenModules != nullptr);
+  TORCH_INTERNAL_ASSERT(PyImport_FrozenModules != nullptr);
 
   appendCPythonInittab();
 }
@@ -83,15 +83,15 @@ sys.meta_path.insert(0, F())
 )PYTHON";
 
 void BuiltinRegistry::runPostInitialization() {
-  MULTIPY_INTERNAL_ASSERT(Py_IsInitialized());
+  TORCH_INTERNAL_ASSERT(Py_IsInitialized());
   std::string metaPathSetupScript(metaPathSetupTemplate);
   std::string replaceKey = "<<<DEPLOY_BUILTIN_MODULES_CSV>>>";
   auto itr = metaPathSetupScript.find(replaceKey);
   if (itr != std::string::npos) {
     metaPathSetupScript.replace(itr, replaceKey.size(), getBuiltinModulesCSV());
   }
   int r = PyRun_SimpleString(metaPathSetupScript.c_str());
-  MULTIPY_INTERNAL_ASSERT(r == 0);
+  TORCH_INTERNAL_ASSERT(r == 0);
 }
 
 void BuiltinRegistry::registerBuiltin(
@@ -152,22 +152,22 @@ void BuiltinRegistry::sanityCheck() {
   auto* cpythonInternalFrozens = getItem("cpython_internal");
   // Num frozen builtins shouldn't change (unless modifying the underlying
   // cpython version)
-  MULTIPY_INTERNAL_ASSERT(
+  TORCH_INTERNAL_ASSERT(
       cpythonInternalFrozens != nullptr &&
           cpythonInternalFrozens->numModules == NUM_FROZEN_PY_BUILTIN_MODULES,
       "Missing python builtin frozen modules");
 
   auto* frozenpython = getItem("frozenpython");
 #ifdef FBCODE_CAFFE2
-  MULTIPY_INTERNAL_ASSERT(
+  TORCH_INTERNAL_ASSERT(
       frozenpython != nullptr, "Missing frozen python modules");
 #else
   auto* frozentorch = getItem("frozentorch");
   // Check frozenpython+frozentorch together since in OSS frozenpython is empty
   // and frozentorch contains stdlib+torch, while in fbcode they are separated
   // due to thirdparty2 frozenpython. No fixed number of torch modules to check
   // for, but there should be at least one.
-  MULTIPY_INTERNAL_ASSERT(
+  TORCH_INTERNAL_ASSERT(
       frozenpython != nullptr && frozentorch != nullptr &&
           frozenpython->numModules + frozentorch->numModules >
               NUM_FROZEN_PY_STDLIB_MODULES + 1,

torch/csrc/deploy/interpreter/builtin_registry.cpp

@@ -15,8 +15,8 @@
    the client application.
 
    It is safe to throw exception types that are defined once in
-   the context of the client application, such as std::runtime_error,
-   which isn't duplicated in torch::deploy interpreters.
+   the context of the client application, such as c10::Error, which is defined
+   in libtorch, which isn't duplicated in torch::deploy interpreters.
 
    ==> Use TORCH_DEPLOY_TRY, _SAFE_CATCH_RETHROW around _ALL_ torch::deploy APIs
 
@@ -30,16 +30,20 @@
 
 */
 #define TORCH_DEPLOY_TRY try {
-#define TORCH_DEPLOY_SAFE_CATCH_RETHROW                                    \
-  }                                                                        \
-  catch (std::exception & err) {                                           \
-    throw std::runtime_error(                                              \
-        "Exception Caught inside torch::deploy embedded library: \n" +     \
-        std::string(err.what()));                                          \
-  }                                                                        \
-  catch (...) {                                                            \
-    throw std::runtime_error(                                              \
-        "Unknown Exception Caught inside torch::deploy embedded library"); \
+#define TORCH_DEPLOY_SAFE_CATCH_RETHROW                                        \
+  }                                                                            \
+  catch (std::exception & err) {                                               \
+    throw c10::Error(                                                          \
+        std::string(                                                           \
+            "Exception Caught inside torch::deploy embedded library: \n") +    \
+            err.what(),                                                        \
+        "");                                                                   \
+  }                                                                            \
+  catch (...) {                                                                \
+    throw c10::Error(                                                          \
+        std::string(                                                           \
+            "Unknown Exception Caught inside torch::deploy embedded library"), \
+        "");                                                                   \
   }
 namespace torch {
 namespace deploy {

torch/csrc/deploy/interpreter/interpreter_impl.h

@@ -1,9 +1,9 @@
 #pragma once
 
+#include <c10/util/Exception.h>
 #include <fcntl.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
-#include <torch/csrc/deploy/Exception.h>
 #include <unistd.h>
 #include <cerrno>
 #include <cstdio>
@@ -20,21 +20,18 @@ namespace deploy {
 struct MemFile {
   explicit MemFile(const char* filename_) : fd_(0), mem_(nullptr), n_bytes_(0) {
     fd_ = open(filename_, O_RDONLY);
-    MULTIPY_CHECK(
-        fd_ != -1, "failed to open " + filename_ + ": " + strerror(errno));
+    TORCH_CHECK(fd_ != -1, "failed to open {}: {}", filename_, strerror(errno));
     // NOLINTNEXTLINE
     struct stat s;
     if (-1 == fstat(fd_, &s)) {
       close(fd_); // destructors don't run during exceptions
-      MULTIPY_CHECK(
-          false, "failed to stat " + filename_ + ": " + strerror(errno));
+      TORCH_CHECK(false, "failed to stat {}: {}", filename_, strerror(errno));
     }
     n_bytes_ = s.st_size;
     mem_ = mmap(nullptr, n_bytes_, PROT_READ, MAP_SHARED, fd_, 0);
     if (MAP_FAILED == mem_) {
       close(fd_);
-      MULTIPY_CHECK(
-          false, "failed to mmap " + filename_ + ": " + strerror(errno));
+      TORCH_CHECK(false, "failed to mmap {}: {}", filename_, strerror(errno));
     }
   }
   MemFile(const MemFile&) = delete;