text: /*
   * Copyright (c) 2021, NVIDIA CORPORATION.  All rights reserved.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  #ifndef TENSORRT_SAFE_COMMON_H
  #define TENSORRT_SAFE_COMMON_H
  
  #include <cstdlib>
  #include <iostream>
  #include <memory>
  #include <stdexcept>
  #include <string>
  
  #define CHECK(status)                                                                                                  \
      do                                                                                                                 \
      {                                                                                                                  \
          auto ret = (status);                                                                                           \
          if (ret != 0)                                                                                                  \
          {                                                                                                              \
              std::cerr << "Cuda failure: " << ret << std::endl;                                                         \
              abort();                                                                                                   \
          }                                                                                                              \
      } while (0)
  
  namespace samplesCommon
  {
  template <typename T>
  inline std::shared_ptr<T> infer_object(T* obj)
  {
      if (!obj)
      {
          throw std::runtime_error("Failed to create object");
      }
      return std::shared_ptr<T>(obj);
  }
  
  inline uint32_t elementSize(DataType t)
  {
      switch (t)
      {
      case DataType::kINT32:
      case DataType::kFLOAT: return 4;
      case DataType::kHALF: return 2;
      case DataType::kINT8: return 1;
      case DataType::kBOOL: return 1;
      }
      return 0;
  }
  
  template <typename A, typename B>
  inline A divUp(A x, B n)
  {
      return (x + n - 1) / n;
  }
  
  } // namespace samplesCommon
  
  #endif // TENSORRT_SAFE_COMMON_H
  