diff --git a/.clang-tidy b/.clang-tidy index aa2bf56185dc13..3513ae8dbbebab 100644 --- a/.clang-tidy +++ b/.clang-tidy @@ -1,51 +1,11 @@ --- # NOTE: there must be no spaces before the '-', so put the comma first. Checks: ' - * - ,clang-analyzer-* - ,modernize-* - ,-cert-dcl21-cpp - ,-cert-err58-cpp - ,-cert-err60-cpp - ,-clang-diagnostic-* - ,-cppcoreguidelines-owning-memory - ,-cppcoreguidelines-pro-bounds-array-to-pointer-decay - ,-cppcoreguidelines-pro-bounds-constant-array-index - ,-cppcoreguidelines-pro-type-member-init - ,-cppcoreguidelines-pro-type-static-cast-downcast - ,-cppcoreguidelines-pro-type-union-access - ,-cppcoreguidelines-pro-type-vararg - ,-cppcoreguidelines-special-member-functions - ,-fuchsia-* - ,-google-build-using-namespace - ,-google-default-arguments - ,-google-explicit-constructor - ,-google-readability-braces-around-statements - ,-google-readability-namespace-comments - ,-google-readability-todo - ,-google-runtime-references - ,-google-runtime-references - ,-hicpp-braces-around-statements - ,-hicpp-explicit-conversions - ,-hicpp-member-init - ,-hicpp-no-array-decay - ,-hicpp-signed-bitwise - ,-hicpp-special-member-functions - ,-hicpp-vararg - ,-llvm-header-guard - ,-llvm-include-order - ,-llvm-namespace-comment - ,-misc-unused-parameters - ,-modernize-make-unique - ,-modernize-use-default-member-init - ,-performance-unnecessary-value-param - ,-readability-braces-around-statements - ,-readability-else-after-return - ,-readability-implicit-bool-conversion - ,-readability-named-parameter + -* + ,modernize-deprecated-headers ' -WarningsAsErrors: '' -HeaderFilterRegex: 'torch/csrc/' +WarningsAsErrors: '*' +HeaderFilterRegex: 'torch/csrc/.*' AnalyzeTemporaryDtors: false CheckOptions: ... diff --git a/.travis.yml b/.travis.yml index 77d430ee8917a4..f26ad6c1de1d08 100644 --- a/.travis.yml +++ b/.travis.yml @@ -29,3 +29,12 @@ matrix: - env: CPP_DOC_CHECK install: sudo apt-get install -y doxygen script: cd docs/cpp/source && ./check-doxygen.sh + - env: CLANG_TIDY + python: "3.6" + addons: + apt: + sources: + - ubuntu-toolchain-r-test + - llvm-toolchain-trusty-6.0 + packages: clang-tidy-6.0 + script: tools/run-clang-tidy-in-ci.sh -e "$(which clang-tidy-6.0)" diff --git a/CMakeLists.txt b/CMakeLists.txt index 488605d5ea459e..8212aaf98fcb59 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -10,6 +10,8 @@ if (NOT MSVC) set(CMAKE_C_STANDARD 11) endif() +set(CMAKE_EXPORT_COMPILE_COMMANDS ON) + # One variable that determines whether the current cmake process is being run # with the main Caffe2 library. This is useful for building modules - if # modules are built with the main Caffe2 library then one does not need to do diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index f0be7e770b97e4..57800d887f2d75 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -354,6 +354,36 @@ static_assert(std::is_same(A*, decltype(A::singelton()))::value, "hmm"); are too large. Splitting such files into separate files helps. (Example: `THTensorMath`, `THTensorMoreMath`, `THTensorEvenMoreMath`.) +### Running Clang-Tidy + +[Clang-Tidy](https://clang.llvm.org/extra/clang-tidy/index.html) is a C++ +linter and static analysis tool based on the clang compiler. We run clang-tidy +in our CI to make sure that new C++ code is safe, sane and efficient. See our +[.travis.yml](https://github.com/pytorch/pytorch/blob/master/.travis.yml) file +for the simple commands we use for this. + +To run clang-tidy locally, follow these steps: + +1. Install clang-tidy. First, check if you already have clang-tidy by simply +writing `clang-tidy` in your terminal. If you don't yet have clang-tidy, you +should be able to install it easily with your package manager, e.g. by writing +`apt-get install clang-tidy` on Ubuntu. See https://apt.llvm.org for details on +how to install the latest version. Note that newer versions of clang-tidy will +have more checks than older versions. In our CI, we run clang-tidy-6.0. + +2. Use our driver script to run clang-tidy over any changes relative to some + git revision (you may want to replace `HEAD~1` with `HEAD` to pick up + uncommitted changes). Changes are picked up based on a `git diff` with the + given revision: + ```sh + $ python tools/clang_tidy.py -d build -p torch/csrc -r HEAD~1 + ``` + +Above, it is assumed you are in the PyTorch root folder. `path/to/build` should +be the path to where you built PyTorch from source, e.g. `build` in the PyTorch +root folder if you used `setup.py build`. You can use `-c ` +to change the clang-tidy this script uses. + ## Caffe2 notes In 2018, we merged Caffe2 into the PyTorch source repository. While the diff --git a/README.md b/README.md index 918aac0627cf2d..a14a1605544437 100644 --- a/README.md +++ b/README.md @@ -77,7 +77,7 @@ change the way your network behaves arbitrarily with zero lag or overhead. Our i from several research papers on this topic, as well as current and past work such as [torch-autograd](https://github.com/twitter/torch-autograd), [autograd](https://github.com/HIPS/autograd), -[Chainer](http://chainer.org), etc. +[Chainer](https://chainer.org), etc. While this technique is not unique to PyTorch, it's one of the fastest implementations of it to date. You get the best of speed and flexibility for your crazy research. @@ -121,10 +121,10 @@ Writing new neural network modules, or interfacing with PyTorch's Tensor API was and with minimal abstractions. You can write new neural network layers in Python using the torch API -[or your favorite NumPy-based libraries such as SciPy](http://pytorch.org/tutorials/advanced/numpy_extensions_tutorial.html). +[or your favorite NumPy-based libraries such as SciPy](https://pytorch.org/tutorials/advanced/numpy_extensions_tutorial.html). If you want to write your layers in C/C++, we provide a convenient extension API that is efficient and with minimal boilerplate. -There is no wrapper code that needs to be written. You can see [a tutorial here](http://pytorch.org/tutorials/advanced/cpp_extension.html) and [an example here](https://github.com/pytorch/extension-cpp). +There is no wrapper code that needs to be written. You can see [a tutorial here](https://pytorch.org/tutorials/advanced/cpp_extension.html) and [an example here](https://github.com/pytorch/extension-cpp). ## Installation @@ -132,7 +132,7 @@ There is no wrapper code that needs to be written. You can see [a tutorial here] ### Binaries Commands to install from binaries via Conda or pip wheels are on our website: -[http://pytorch.org](http://pytorch.org) +[https://pytorch.org](https://pytorch.org) ### From Source @@ -239,7 +239,7 @@ You can then build the documentation by running ``make `` from the ### Previous Versions Installation instructions and binaries for previous PyTorch versions may be found -on [our website](http://pytorch.org/previous-versions). +on [our website](https://pytorch.org/previous-versions). ## Getting Started @@ -247,13 +247,13 @@ on [our website](http://pytorch.org/previous-versions). Three pointers to get you started: - [Tutorials: get you started with understanding and using PyTorch](https://pytorch.org/tutorials/) - [Examples: easy to understand pytorch code across all domains](https://github.com/pytorch/examples) -- [The API Reference](http://pytorch.org/docs/) +- [The API Reference](https://pytorch.org/docs/) ## Communication -* forums: discuss implementations, research, etc. http://discuss.pytorch.org +* forums: discuss implementations, research, etc. https://discuss.pytorch.org * GitHub issues: bug reports, feature requests, install issues, RFCs, thoughts, etc. * Slack: general chat, online discussions, collaboration etc. https://pytorch.slack.com/ . Our slack channel is invite-only to promote a healthy balance between power-users and beginners. If you need a slack invite, ping us at slack@pytorch.org -* newsletter: no-noise, one-way email newsletter with important announcements about pytorch. You can sign-up here: http://eepurl.com/cbG0rv +* newsletter: no-noise, one-way email newsletter with important announcements about pytorch. You can sign-up here: https://eepurl.com/cbG0rv ## Releases and Contributing diff --git a/aten/src/ATen/core/TensorImpl.cpp b/aten/src/ATen/core/TensorImpl.cpp index d8f38e98ef4434..41cff4f8b6de60 100644 --- a/aten/src/ATen/core/TensorImpl.cpp +++ b/aten/src/ATen/core/TensorImpl.cpp @@ -31,31 +31,32 @@ TensorImpl::TensorImpl(Storage&& storage, TensorTypeId type_id, bool is_variable TensorImpl::TensorImpl(Storage&& storage, TensorTypeId type_id, const caffe2::TypeMeta& data_type, bool is_variable) : storage_(std::move(storage)), - storage_offset_(0), sizes_{0}, - strides_{1}, - is_contiguous_(true), + storage_offset_(0), numel_(0), - type_id_(type_id), data_type_(data_type), - is_variable_(is_variable) {} + type_id_(type_id), + is_variable_(is_variable) { + strides_.reset(new int64_t[1]); + strides_[0] = 1; +} IntList TensorImpl::sizes() const { return sizes_; } IntList TensorImpl::strides() const { - AT_ASSERTM(strides_.size() == sizes_.size(), + AT_ASSERTM(strides_, "Caffe2 tensors don't (yet) have meaningful strides and cannot " "be used in PyTorch."); - return strides_; + return IntList{strides_.get(), sizes_.size()}; } bool TensorImpl::compute_contiguous() const { bool is_contiguous = true; if (is_empty()) return is_contiguous; - if (strides_.empty()) { + if (!strides_) { // Special case for Caffe2 tensors which don't have strides set. return true; } @@ -89,7 +90,7 @@ int64_t TensorImpl::size(int64_t d) const { } int64_t TensorImpl::stride(int64_t d) const { - AT_ASSERTM(strides_.size() == sizes_.size(), + AT_ASSERTM(strides_, "Caffe2 tensors don't (yet) have meaningful strides and cannot " "be used in PyTorch."); d = at::maybe_wrap_dim(d, dim(), false); diff --git a/aten/src/ATen/core/TensorImpl.h b/aten/src/ATen/core/TensorImpl.h index 7d7ce6a980249c..7662069a43cbd7 100644 --- a/aten/src/ATen/core/TensorImpl.h +++ b/aten/src/ATen/core/TensorImpl.h @@ -10,7 +10,6 @@ #include "ATen/core/LegacyTypeDispatch.h" #include "ATen/core/Backend.h" #include "ATen/core/context_base.h" -#include "ATen/core/WrapDimMinimal.h" #include "caffe2/core/allocator.h" #include "caffe2/core/common.h" @@ -90,6 +89,16 @@ inline int64_t size_between_dim_(int k, int l, IntList dims) { return r; } +// Wrap around axis_index if it is negative, s.t., -1 is the last dim +inline int canonical_axis_index_(int axis_index, int ndims) { + CAFFE_ENFORCE_GE(axis_index, -ndims); + CAFFE_ENFORCE_LT(axis_index, ndims); + if (axis_index < 0) { + return axis_index + ndims; + } + return axis_index; +} + /** * The low-level representation of a tensor, which contains a storage * (which contains the actual data) and metadata (e.g., sizes and strides) @@ -218,11 +227,6 @@ struct CAFFE2_API TensorImpl : public c10::intrusive_ptr_target { virtual Tensor& grad(); virtual const Tensor& grad() const; - // TODO: make these protected - // Note: storage->size() may be greater than the recorded size - // of a tensor - at::Storage storage_; - template inline T * data() const { AT_ASSERT(!is_variable()); @@ -275,8 +279,17 @@ struct CAFFE2_API TensorImpl : public c10::intrusive_ptr_target { virtual void resize_dim(int64_t ndim) { // NB: This is *truly* a resize; calling code (e.g., squeeze) // assumes that old values are preserved + auto old_dim = sizes_.size(); sizes_.resize(ndim); - strides_.resize(ndim); + auto new_strides = c10::guts::make_unique(ndim); + for (size_t i = 0; i < std::min(old_dim, static_cast(ndim)); i++) { + new_strides[i] = strides_[i]; + } + for (size_t i = old_dim; i < static_cast(ndim); i++) { + // If ndim < old_dim, this loop never executes + new_strides[i] = 0; + } + strides_ = std::move(new_strides); refresh_numel(); refresh_contiguous(); } @@ -288,7 +301,9 @@ struct CAFFE2_API TensorImpl : public c10::intrusive_ptr_target { } virtual void set_stride(int64_t dim, int64_t new_stride) { - strides_.at(dim) = new_stride; + AT_ASSERTM(strides_, "Caffe2 tensors don't have meaningful strides and " + "cannot be used in PyTorch"); + strides_[dim] = new_stride; refresh_numel(); refresh_contiguous(); } @@ -311,8 +326,14 @@ struct CAFFE2_API TensorImpl : public c10::intrusive_ptr_target { ") must match dimensionality of strides (", new_stride.size(), ")"); + auto old_dim = sizes_.size(); sizes_ = new_size.vec(); - strides_ = new_stride.vec(); + if (old_dim != sizes_.size()) { + strides_.reset(new int64_t[sizes_.size()]); + } + for (size_t i = 0; i < sizes_.size(); i++) { + strides_[i] = new_stride[i]; + } refresh_numel(); refresh_contiguous(); } @@ -323,13 +344,6 @@ struct CAFFE2_API TensorImpl : public c10::intrusive_ptr_target { bool is_variable() const { return is_variable_; }; private: - int64_t storage_offset_ = 0; - std::vector sizes_; - std::vector strides_; - - bool is_contiguous_ = true; - int64_t numel_ = -1; - int64_t compute_numel() const { int64_t n = 1; for (auto s : sizes()) { @@ -348,12 +362,6 @@ struct CAFFE2_API TensorImpl : public c10::intrusive_ptr_target { AT_ASSERT(!is_variable()); is_contiguous_ = compute_contiguous(); } - TensorTypeId type_id_; - // INVARIANT: When storage is non-null, this type meta must - // agree with the type meta in storage - caffe2::TypeMeta data_type_; - bool is_variable_ = false; - bool is_wrapped_number_ = false; private: TensorImpl(Storage&& storage, TensorTypeId type_id, const caffe2::TypeMeta& data_type, bool is_variable); @@ -399,7 +407,7 @@ struct CAFFE2_API TensorImpl : public c10::intrusive_ptr_target { if (src.numel() == -1) { sizes_.clear(); numel_ = -1; - strides_.clear(); + strides_.reset(); is_contiguous_ = true; storage_.reset(); data_type_ = caffe2::TypeMeta(); @@ -785,13 +793,6 @@ struct CAFFE2_API TensorImpl : public c10::intrusive_ptr_target { return sizes_; } - protected: - // we decide to keep reserved_ and it will - // live in Tensor after the split - // The logic is that if Extend() or ReserveSpace() were ever called, - // then subsequent Resize()s will not free up Storage. - bool reserved_ = false; - private: template < typename T, @@ -864,9 +865,35 @@ struct CAFFE2_API TensorImpl : public c10::intrusive_ptr_target { } inline void update_to_contiguous_strides() { - strides_.resize(0); + strides_.reset(); is_contiguous_ = true; } +public: + at::Storage storage_; // TODO: Fix visibility on me + +protected: + std::vector sizes_; + std::unique_ptr strides_; // this saves two words + + int64_t storage_offset_ = 0; + int64_t numel_ = -1; + + // INVARIANT: When storage is non-null, this type meta must + // agree with the type meta in storage + caffe2::TypeMeta data_type_; + + // You get to have eight byte-size fields here, before you + // should pack this into a bitfield. + TensorTypeId type_id_; + bool is_contiguous_ = true; + bool is_variable_ = false; + bool is_wrapped_number_ = false; + // we decide to keep reserved_ and it will + // live in Tensor after the split + // The logic is that if Extend() or ReserveSpace() were ever called, + // then subsequent Resize()s will not free up Storage. + bool reserved_ = false; + }; } // namespace at diff --git a/aten/src/ATen/core/WrapDimMinimal.h b/aten/src/ATen/core/WrapDimMinimal.h index 859c1da0590a9d..6971bac0b3f67c 100644 --- a/aten/src/ATen/core/WrapDimMinimal.h +++ b/aten/src/ATen/core/WrapDimMinimal.h @@ -20,10 +20,4 @@ static inline int64_t maybe_wrap_dim(int64_t dim, int64_t dim_post_expr, bool wr return dim; } -// Wrap around axis_index if it is negative, s.t., -1 is the last dim -// This is the "Caffe2" name -static inline int canonical_axis_index_(int axis_index, int ndims) { - return maybe_wrap_dim(axis_index, ndims, false); -} - } diff --git a/aten/src/ATen/core/ivalue.cpp b/aten/src/ATen/core/ivalue.cpp index 5df0a5b49ca93b..58e90516c9c345 100644 --- a/aten/src/ATen/core/ivalue.cpp +++ b/aten/src/ATen/core/ivalue.cpp @@ -6,9 +6,11 @@ _(Tensor) \ _(Double) \ _(Int) \ + _(Bool) \ _(Tuple) \ _(IntList) \ _(DoubleList) \ + _(BoolList) \ _(String) \ _(TensorList) \ _(Blob) \ diff --git a/aten/src/ATen/core/ivalue.h b/aten/src/ATen/core/ivalue.h index 5e210d638d9226..0bdd85a587b3b1 100644 --- a/aten/src/ATen/core/ivalue.h +++ b/aten/src/ATen/core/ivalue.h @@ -74,6 +74,7 @@ struct C10_EXPORT Tuple : public List { using IntList = List; using TensorList = List; using DoubleList = List; +using BoolList = List; using GenericList = List; // IValue is the generic tagged union used by the interpreter to hold @@ -88,9 +89,11 @@ using GenericList = List; _(Tensor) \ _(Double) \ _(Int) \ + _(Bool) \ _(Tuple) \ _(IntList) \ _(DoubleList) \ + _(BoolList) \ _(String) \ _(TensorList) \ _(Blob) \ @@ -224,8 +227,6 @@ struct CAFFE2_API IValue final { // allow you to pass literals (3, 4) without ambiguity IValue(int32_t i) : IValue(static_cast(i)) {} - IValue(bool b) - : IValue(static_cast(b)) {} bool isInt() const { return Tag::Int == tag; } @@ -234,6 +235,17 @@ struct CAFFE2_API IValue final { return payload.as_int; } + // Bool + IValue(bool b) + : tag(Tag::Bool), is_intrusive_ptr(false) { + payload.as_bool = b; + } + bool isBool() const { return Tag::Bool == tag; } + bool toBool() const { + AT_ASSERT(isBool()); + return payload.as_bool; + } + // IntList IValue(c10::intrusive_ptr v); IValue(std::vector v); @@ -251,6 +263,7 @@ struct CAFFE2_API IValue final { const std::vector& toIntListRef() const; const std::vector& toDoubleListRef() const; + const std::vector& toBoolListRef() const; const std::vector& toTensorListRef() const; const std::vector& toGenericListRef() const; @@ -280,6 +293,19 @@ struct CAFFE2_API IValue final { return toIntrusivePtr(); } + // BoolList + IValue(c10::intrusive_ptr v); + IValue(std::vector v); + bool isBoolList() const { return Tag::BoolList == tag; } + c10::intrusive_ptr toBoolList() && { + AT_ASSERT(isBoolList()); + return moveToIntrusivePtr(); + } + c10::intrusive_ptr toBoolList() const & { + AT_ASSERT(isBoolList()); + return toIntrusivePtr(); + } + //TensorList IValue(c10::intrusive_ptr v); IValue(std::vector v); @@ -323,15 +349,16 @@ struct CAFFE2_API IValue final { } } bool isScalar() { - return isDouble() || isInt(); + return isDouble() || isInt() || isBool(); } at::Scalar toScalar() const { if(isDouble()) return toDouble(); else if(isInt()) return toInt(); - else - throw std::runtime_error("IValue is not a Scalar"); + else if (isBool()) + return int(toBool()); + throw std::runtime_error("IValue is not a Scalar"); } // for debugging @@ -396,6 +423,7 @@ struct CAFFE2_API IValue final { union { int64_t as_int; double as_double; + bool as_bool; c10::intrusive_ptr_target* as_intrusive_ptr; World as_world; } payload; @@ -419,15 +447,16 @@ DEFINE_TO(at::Tensor, toTensor) DEFINE_TO(c10::intrusive_ptr, toTuple) DEFINE_TO(double, toDouble) DEFINE_TO(int64_t, toInt) +DEFINE_TO(bool, toBool) DEFINE_TO(c10::intrusive_ptr, toDoubleList) DEFINE_TO(c10::intrusive_ptr, toIntList) DEFINE_TO(c10::intrusive_ptr, toTensorList) DEFINE_TO(c10::intrusive_ptr, toGenericList) DEFINE_TO(c10::intrusive_ptr, toString) DEFINE_TO(at::Scalar, toScalar) -DEFINE_TO(bool, toInt) DEFINE_TO(std::vector, toIntListRef) DEFINE_TO(std::vector, toDoubleListRef) +DEFINE_TO(std::vector, toBoolListRef) DEFINE_TO(std::vector, toTensorListRef) DEFINE_TO(std::vector, toGenericListRef) DEFINE_TO(World, toWorld) @@ -490,6 +519,13 @@ inline IValue::IValue(c10::intrusive_ptr v) inline IValue::IValue(std::vector v) : IValue(DoubleList::create(std::move(v))) {} +inline IValue::IValue(c10::intrusive_ptr v) +: tag(Tag::BoolList), is_intrusive_ptr(true) { + payload.as_intrusive_ptr = v.release(); +} +inline IValue::IValue(std::vector v) +: IValue(BoolList::create(std::move(v))) {} + inline IValue::IValue(c10::intrusive_ptr v) : tag(Tag::TensorList), is_intrusive_ptr(true) { payload.as_intrusive_ptr = v.release(); @@ -517,6 +553,10 @@ inline const std::vector& IValue::toTensorListRef() const { return toTensorList()->elements(); } +inline const std::vector& IValue::toBoolListRef() const { + return toBoolList()->elements(); +} + inline const std::vector& IValue::toGenericListRef() const { return toGenericList()->elements(); } diff --git a/aten/src/THC/THCTensorMathReduce.cuh b/aten/src/THC/THCTensorMathReduce.cuh index be5aa84491eb94..fbff69ac55c29d 100644 --- a/aten/src/THC/THCTensorMathReduce.cuh +++ b/aten/src/THC/THCTensorMathReduce.cuh @@ -315,7 +315,7 @@ __host__ void THCTensor_varOuterDim(THCState *state, TensorTypeK *tgt, TensorTyp tgt->template data(), src->template data(), num_orows, num_irows, row_size); } - cudaError errcode = cudaGetLastError(); + cudaError_t errcode = cudaGetLastError(); if (errcode != cudaSuccess) THError(cudaGetErrorString(errcode)); } @@ -456,7 +456,7 @@ __host__ void THCTensor_varInnermostDim(THCState *state, TensorTypeK *tgt, Tenso tgt->template data(), src->template data(), num_rows, row_size); } - cudaError errcode = cudaGetLastError(); + cudaError_t errcode = cudaGetLastError(); if (errcode != cudaSuccess) THError(cudaGetErrorString(errcode)); } diff --git a/aten/src/THC/generic/THCTensorMathReduce.cu b/aten/src/THC/generic/THCTensorMathReduce.cu index 4d7e81750c0ec7..ce9e46a53b2925 100644 --- a/aten/src/THC/generic/THCTensorMathReduce.cu +++ b/aten/src/THC/generic/THCTensorMathReduce.cu @@ -73,7 +73,7 @@ void THCTensor_(renorm)(THCState *state, THCTensor* self, THCTensor* src, scalar <<>> (THCTensor_(data)(state, data), scalar_cast(value), size, scalar_cast(maxnorm)); - cudaError errcode = cudaGetLastError(); + cudaError_t errcode = cudaGetLastError(); if(errcode != cudaSuccess) THError(cudaGetErrorString(errcode)); } diff --git a/binaries/CMakeLists.txt b/binaries/CMakeLists.txt index 729ad5170d7cb0..1ff15d8cade089 100644 --- a/binaries/CMakeLists.txt +++ b/binaries/CMakeLists.txt @@ -54,6 +54,8 @@ endif() if (USE_OPENCV) caffe2_binary_target("make_image_db.cc") target_link_libraries(make_image_db ${OpenCV_LIBS}) + caffe2_binary_target("convert_image_to_tensor.cc") + target_link_libraries(convert_image_to_tensor ${OpenCV_LIBS}) endif() if (USE_OBSERVERS) diff --git a/binaries/benchmark_helper.cc b/binaries/benchmark_helper.cc index ecbae477282c15..53a1ee2c6bd9a0 100644 --- a/binaries/benchmark_helper.cc +++ b/binaries/benchmark_helper.cc @@ -190,7 +190,7 @@ void fillInputBlob( if (tensor_protos_map.empty()) { return; } - + static caffe2::TensorDeserializer serializer; for (auto& tensor_kv : tensor_protos_map) { caffe2::Blob* blob = workspace->GetBlob(tensor_kv.first); if (blob == nullptr) { @@ -200,17 +200,22 @@ void fillInputBlob( int protos_size = tensor_kv.second.protos_size(); caffe2::TensorProto* tensor_proto = tensor_kv.second.mutable_protos(iteration % protos_size); - caffe2::TensorCPU* tensor = BlobGetMutableTensor(blob, caffe2::CPU); if (tensor_proto->data_type() == caffe2::TensorProto::STRING) { + caffe2::TensorCPU* tensor = BlobGetMutableTensor(blob, caffe2::CPU); int total_size = tensor_proto->string_data_size(); for (size_t i = 0; i < total_size; i++) { (tensor->mutable_data())[i] = tensor_proto->string_data(i); } } else if (tensor_proto->data_type() == caffe2::TensorProto::FLOAT) { - int total_size = tensor_proto->float_data_size(); - for (size_t i = 0; i < total_size; i++) { - (tensor->mutable_data())[i] = tensor_proto->float_data(i); + vector dims; + for (const int64_t d : tensor_proto->dims()) { + dims.push_back(d); } + // int total_size = tensor_proto->float_data_size(); + caffe2::TensorCPU* tensor = + new caffe2::TensorCPU(dims, caffe2::DeviceType::CPU); + serializer.Deserialize(*tensor_proto, tensor); + blob->Reset(tensor); } // todo: for other types } @@ -255,6 +260,9 @@ void runNetwork( for (int i = 0; i < iter; ++i) { caffe2::ObserverConfig::initSampleRate(1, 1, 1, 0, warmup); fillInputBlob(workspace, tensor_protos_map, i); + if (wipe_cache) { + caffe2::wipe_cache(); + } CAFFE_ENFORCE(net->Run(), "Main run ", i, " has failed."); if (wipe_cache) { caffe2::wipe_cache(); @@ -262,9 +270,6 @@ void runNetwork( if (run_individual) { caffe2::ObserverConfig::initSampleRate(1, 1, 1, 1, warmup); CAFFE_ENFORCE(net->Run(), "Main run ", i, " with operator has failed."); - if (wipe_cache) { - caffe2::wipe_cache(); - } } } } @@ -335,15 +340,18 @@ int benchmark( // file does not exist std::ifstream net_file(FLAGS_net); CAFFE_ENFORCE(net_file.good()); + net_file.close(); std::ifstream init_net_file(FLAGS_init_net); CAFFE_ENFORCE(init_net_file.good()); + init_net_file.close(); if (FLAGS_input_file.size() > 0) { vector input_files = caffe2::split(',', FLAGS_input_file); for (auto input_file : input_files) { std::ifstream ifile(input_file); CAFFE_ENFORCE(ifile.good()); + ifile.close(); } } } diff --git a/binaries/benchmark_helper.h b/binaries/benchmark_helper.h index 5bf79182dab7e1..1cb1fe5e4c4229 100644 --- a/binaries/benchmark_helper.h +++ b/binaries/benchmark_helper.h @@ -34,37 +34,52 @@ void writeTextOutput( TensorType* tensor, const string& output_prefix, const string& name) { - string output_name = output_prefix + "/" + name + ".txt"; + string filename = name; + std::replace(filename.begin(), filename.end(), '/', '_'); + string output_name = output_prefix + "/" + filename + ".txt"; caffe2::TensorSerializer ser; caffe2::BlobProto blob_proto; + ser.Serialize( *tensor, output_name, blob_proto.mutable_tensor(), 0, tensor->size()); blob_proto.set_name(output_name); blob_proto.set_type("Tensor"); CAFFE_ENFORCE(blob_proto.has_tensor()); caffe2::TensorProto tensor_proto = blob_proto.tensor(); - vector data; - switch (tensor_proto.data_type()) { - case caffe2::TensorProto::FLOAT: { - std::copy( - tensor_proto.float_data().begin(), - tensor_proto.float_data().end(), - std::back_inserter(data)); - break; - } - case caffe2::TensorProto::INT32: { - std::copy( - tensor_proto.int32_data().begin(), - tensor_proto.int32_data().end(), - std::back_inserter(data)); - break; - } - default: + int dims_size = tensor_proto.dims_size(); + // For NCHW or NHWC, print one line per CHW/HWC. + // If the output is one dimension, it means N==1, + // print everything to one line. + int loop_count = dims_size > 1 ? tensor_proto.dims(0) : 1; + long long elem_dim_size = + dims_size > 1 ? tensor_proto.dims(1) : tensor_proto.dims(0); + for (int i = 2; i < dims_size; i++) { + elem_dim_size *= tensor_proto.dims(i); + } + std::vector lines; + for (int i = 0; i < loop_count; i++) { + int start_idx = i * elem_dim_size; + std::stringstream line; + if (tensor_proto.data_type() == caffe2::TensorProto::FLOAT) { + auto start = tensor_proto.float_data().begin() + start_idx; + auto end = start + elem_dim_size; + copy(start, end, std::ostream_iterator(line, ",")); + } else if (tensor_proto.data_type() == caffe2::TensorProto::INT32) { + auto start = tensor_proto.int32_data().begin() + start_idx; + auto end = start + elem_dim_size; + copy(start, end, std::ostream_iterator(line, ",")); + } else { CAFFE_THROW("Unimplemented Blob type."); + } + // remove the last , + string str = line.str(); + str.pop_back(); + lines.push_back(str); } + std::ofstream output_file(output_name); - std::ostream_iterator output_iterator(output_file, "\n"); - std::copy(data.begin(), data.end(), output_iterator); + std::ostream_iterator output_iterator(output_file, "\n"); + std::copy(lines.begin(), lines.end(), output_iterator); } void observerConfig(); diff --git a/binaries/convert_image_to_tensor.cc b/binaries/convert_image_to_tensor.cc new file mode 100644 index 00000000000000..93efa3f44b32c9 --- /dev/null +++ b/binaries/convert_image_to_tensor.cc @@ -0,0 +1,220 @@ +/** + * Copyright (c) 2016-present, Facebook, Inc. + * + * 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. + */ + +#include +#include + +#include "caffe2/core/common.h" +#include "caffe2/core/db.h" +#include "caffe2/core/init.h" +#include "caffe2/core/logging.h" +#include "caffe2/proto/caffe2_pb.h" +#include "caffe2/utils/proto_utils.h" +#include "caffe2/utils/string_utils.h" + +CAFFE2_DEFINE_bool(color, true, "If set, load images in color."); +CAFFE2_DEFINE_string(input_images, "", "Comma separated images"); +CAFFE2_DEFINE_string(input_image_file, "", "The file containing imput images"); +CAFFE2_DEFINE_string(output_tensor, "", "The output tensor file in NCHW"); +CAFFE2_DEFINE_int(scale, 256, "Scale the shorter edge to the given value."); +CAFFE2_DEFINE_bool(text_output, false, "Write the output in text format."); +CAFFE2_DEFINE_bool(warp, false, "If warp is set, warp the images to square."); +CAFFE2_DEFINE_string( + preprocess, + "", + "Options to specify the preprocess routines. The available options are " + "subtract128, normalize, mean, std, bgrtorgb. If multiple steps are provided, they " + "are separated by comma (,) in sequence."); + +namespace caffe2 { + +cv::Mat resizeImage(cv::Mat& img) { + cv::Mat resized_img; + int scaled_width, scaled_height; + if (caffe2::FLAGS_warp) { + scaled_width = caffe2::FLAGS_scale; + scaled_height = caffe2::FLAGS_scale; + } else if (img.rows > img.cols) { + scaled_width = caffe2::FLAGS_scale; + scaled_height = + static_cast(img.rows) * caffe2::FLAGS_scale / img.cols; + } else { + scaled_height = caffe2::FLAGS_scale; + scaled_width = + static_cast(img.cols) * caffe2::FLAGS_scale / img.rows; + } + cv::resize( + img, + resized_img, + cv::Size(scaled_width, scaled_height), + 0, + 0, + cv::INTER_LINEAR); + return resized_img; +} + +cv::Mat cropToSquare(cv::Mat& img) { + // Crop image to square + if (img.rows != img.cols) { + cv::Mat cropped_img; + int size = img.rows > img.cols ? img.cols : img.rows; + cv::Rect roi; + roi.x = int((img.cols - size) / 2); + roi.y = int((img.rows - size) / 2); + roi.width = size; + roi.height = size; + + cropped_img = img(roi); + return cropped_img; + } else { + return img; + } +} + +std::vector convertToVector(cv::Mat& img) { + std::vector normalize(3, 1); + std::vector mean(3, 0); + std::vector std(3, 1); + bool bgrtorgb = false; + assert(img.cols == caffe2::FLAGS_scale); + assert(img.rows == caffe2::FLAGS_scale); + vector steps = caffe2::split(',', caffe2::FLAGS_preprocess); + for (int i = 0; i < steps.size(); i++) { + auto step = steps[i]; + if (step == "subtract128") { + mean = {128, 128, 128}; + std = {1, 1, 1}; + normalize = {1, 1, 1}; + } else if (step == "normalize") { + normalize = {255, 255, 255}; + } else if (step == "mean") { + mean = {0.406, 0.456, 0.485}; + } else if (step == "std") { + std = {0.225, 0.224, 0.229}; + } else if (step == "bgrtorgb") { + bgrtorgb = true; + } else { + CAFFE_ENFORCE( + false, + "Unsupported preprocess step. The supported steps are: subtract128, " + "normalize,mean, std, swaprb."); + } + } + + int C = caffe2::FLAGS_color ? 3 : 1; + int total_size = C * caffe2::FLAGS_scale * caffe2::FLAGS_scale; + std::vector values(total_size); + if (C == 1) { + cv::MatIterator_ it, end; + int idx = 0; + for (it = img.begin(), end = img.end(); it != end; ++it) { + values[idx++] = (*it / normalize[0] - mean[0]) / std[0]; + } + } else { + int i = 0; + cv::MatIterator_ it, end; + int b = bgrtorgb ? 2 : 0; + int g = 1; + int r = bgrtorgb ? 0 : 2; + for (it = img.begin(), end = img.end(); it != end; + ++it, i++) { + values[i] = (((*it)[b] / normalize[0] - mean[0]) / std[0]); + int offset = caffe2::FLAGS_scale * caffe2::FLAGS_scale + i; + values[offset] = (((*it)[g] / normalize[1] - mean[1]) / std[1]); + offset = caffe2::FLAGS_scale * caffe2::FLAGS_scale + offset; + values[offset] = (((*it)[r] / normalize[2] - mean[2]) / std[2]); + } + } + return values; +} + +std::vector convertOneImage(std::string& filename) { + assert(filename[0] != '~'); + + std::cout << "Converting " << filename << std::endl; + // Load image + cv::Mat img = cv::imread( + filename, + caffe2::FLAGS_color ? CV_LOAD_IMAGE_COLOR : CV_LOAD_IMAGE_GRAYSCALE); + + cv::Mat crop = cropToSquare(img); + + // Resize image + cv::Mat resized_img = resizeImage(crop); + // Assert we don't have to deal with alignment + DCHECK(resized_img.isContinuous()); + assert(resized_img.rows == resized_img.cols); + assert(resized_img.rows == caffe2::FLAGS_scale); + std::vector one_image_values = convertToVector(resized_img); + return one_image_values; +} + +void convertImages() { + vector file_names; + if (caffe2::FLAGS_input_images != "") { + file_names = caffe2::split(',', caffe2::FLAGS_input_images); + } else if (caffe2::FLAGS_input_image_file != "") { + std::ifstream infile(caffe2::FLAGS_input_image_file); + std::string line; + while (std::getline(infile, line)) { + vector file_name = caffe2::split(',', line); + string name; + if (file_name.size() == 3) { + name = file_name[2]; + } else { + name = line; + } + file_names.push_back(name); + } + } else { + assert(false); + } + std::vector> values; + int C = caffe2::FLAGS_color ? 3 : 1; + for (int i = 0; i < file_names.size(); i++) { + std::vector one_image_values = convertOneImage(file_names[i]); + values.push_back(one_image_values); + } + + TensorProtos protos; + TensorProto* data; + data = protos.add_protos(); + data->set_data_type(TensorProto::FLOAT); + data->add_dims(values.size()); + data->add_dims(C); + data->add_dims(caffe2::FLAGS_scale); + data->add_dims(caffe2::FLAGS_scale); + + for (int i = 0; i < values.size(); i++) { + assert(values[i].size() == C * caffe2::FLAGS_scale * caffe2::FLAGS_scale); + for (int j = 0; j < values[i].size(); j++) { + data->add_float_data(values[i][j]); + } + } + if (caffe2::FLAGS_text_output) { + caffe2::WriteProtoToTextFile(protos, caffe2::FLAGS_output_tensor); + } else { + caffe2::WriteProtoToBinaryFile(protos, caffe2::FLAGS_output_tensor); + } +} + +} // namespace caffe2 + +int main(int argc, char** argv) { + caffe2::GlobalInit(&argc, &argv); + caffe2::convertImages(); + return 0; +} diff --git a/caffe2/core/tensor_impl.h b/caffe2/core/tensor_impl.h index 2ee51f655e1e22..17d3b22083bbb1 100644 --- a/caffe2/core/tensor_impl.h +++ b/caffe2/core/tensor_impl.h @@ -3,7 +3,7 @@ #include #include #include -#include +#include namespace caffe2 { using at::ToVectorint64_t; diff --git a/caffe2/operators/hip/conv_op_miopen.cc b/caffe2/operators/hip/conv_op_miopen.cc index 13f2428bf9daa2..c477cd4fef437e 100644 --- a/caffe2/operators/hip/conv_op_miopen.cc +++ b/caffe2/operators/hip/conv_op_miopen.cc @@ -66,19 +66,6 @@ class MIOPENConvOpBase : public ConvPoolOpBase { dilation_h() == 1 && dilation_w() == 1, "MIOpen convolution does not support dilation for groups > 1."); } - - MIOPEN_ENFORCE(miopenInitConvolutionDescriptor( - conv_desc_, - mode_, - pad_t(), - pad_l(), - stride_h(), - stride_w(), - dilation_h(), - dilation_w())); - - MIOPEN_ENFORCE(miopenSetConvolutionGroupCount( - conv_desc_, group_)); } ~MIOPENConvOpBase() { @@ -91,6 +78,8 @@ class MIOPENConvOpBase : public ConvPoolOpBase { } protected: + vector mio_input_dims_; + vector mio_weight_dims_; MIOPENWrapper miopen_wrapper_; miopenTensorDescriptor_t bottom_desc_; miopenTensorDescriptor_t bias_desc_; @@ -257,35 +246,59 @@ bool MIOPENConvOp::DoRunWithType() { "If you set group, the number of output channels should be divisible " "by group."); - MIOPEN_ENFORCE(miopenSet4dTensorDescriptor( - bottom_desc_, miopenTypeWrapper::type, N, C, H, W)); + bool input_changed = (X.dims() != mio_input_dims_); + bool weight_changed = (Weight.dims() != mio_weight_dims_); - MIOPEN_ENFORCE(miopenSet4dTensorDescriptor( - weight_desc_, - miopenTypeWrapper::type, - M, - C / group_, - kernel_h(), - kernel_w())); + if (input_changed || weight_changed) { + VLOG(1) << "Changing MIOpen descriptor configurations."; + if (input_changed) { + mio_input_dims_ = X.dims(); + MIOPEN_ENFORCE(miopenSet4dTensorDescriptor( + bottom_desc_, miopenTypeWrapper::type, N, C, H, W)); + } - MIOPEN_ENFORCE(miopenGetConvolutionForwardOutputDim( - conv_desc_, - bottom_desc_, - weight_desc_, - &N_out, - &C_out, - &H_out, - &W_out)); + if (weight_changed) { + mio_weight_dims_ = Weight.dims(); + MIOPEN_ENFORCE(miopenInitConvolutionDescriptor( + conv_desc_, + mode_, + pad_t(), + pad_l(), + stride_h(), + stride_w(), + dilation_h(), + dilation_w())); - MIOPEN_ENFORCE(miopenSet4dTensorDescriptor( - top_desc_, miopenTypeWrapper::type, N_out, C_out, H_out, W_out)); + MIOPEN_ENFORCE(miopenSetConvolutionGroupCount( + conv_desc_, group_)); - if (InputSize() == 3) { + MIOPEN_ENFORCE(miopenSet4dTensorDescriptor( + weight_desc_, + miopenTypeWrapper::type, + M, + C / group_, + kernel_h(), + kernel_w())); + } + + MIOPEN_ENFORCE(miopenGetConvolutionForwardOutputDim( + conv_desc_, + bottom_desc_, + weight_desc_, + &N_out, + &C_out, + &H_out, + &W_out)); + + MIOPEN_ENFORCE(miopenSet4dTensorDescriptor( + top_desc_, miopenTypeWrapper::type, N_out, C_out, H_out, W_out)); + + if (InputSize() == 3) { MIOPEN_ENFORCE(miopenSet4dTensorDescriptor( bias_desc_, miopenTypeWrapper::type, 1, M, 1, 1)); - } + } - while (!bestAlgoFound_) { + while (!bestAlgoFound_) { miopenConvAlgoPerf_t perf; MIOPEN_ENFORCE(miopenConvolutionForwardGetWorkSpaceSize( @@ -318,6 +331,7 @@ bool MIOPENConvOp::DoRunWithType() { }); bestAlgoFound_ = true; fwdAlgo_ = perf.fwd_algo; + } } miopen_wrapper_.with_miopen_state(miopen_state_, [&](MIOPENState* state) { @@ -424,36 +438,59 @@ bool MIOPENConvGradientOp::DoRunWithType() { "by group."); bool doBwdDataComputation = (OutputSize() == 3 || (no_bias_ && (OutputSize() == 2))); + bool input_changed = (X.dims() != mio_input_dims_); + bool weight_changed = (Weight.dims() != mio_weight_dims_); - MIOPEN_ENFORCE(miopenSet4dTensorDescriptor( - bottom_desc_, miopenTypeWrapper::type, N, C, H, W)); - - MIOPEN_ENFORCE(miopenSet4dTensorDescriptor( - weight_desc_, - miopenTypeWrapper::type, - M, - C / group_, - kernel_h(), - kernel_w())); + if (input_changed || weight_changed) { + VLOG(1) << "Changing MIOpen descriptor configurations."; + if (input_changed) { + mio_input_dims_ = X.dims(); + MIOPEN_ENFORCE(miopenSet4dTensorDescriptor( + bottom_desc_, miopenTypeWrapper::type, N, C, H, W)); + } - MIOPEN_ENFORCE(miopenGetConvolutionForwardOutputDim( - conv_desc_, - bottom_desc_, - weight_desc_, - &N_out, - &C_out, - &H_out, - &W_out)); + if (weight_changed) { + mio_weight_dims_ = Weight.dims(); + MIOPEN_ENFORCE(miopenInitConvolutionDescriptor( + conv_desc_, + mode_, + pad_t(), + pad_l(), + stride_h(), + stride_w(), + dilation_h(), + dilation_w())); - MIOPEN_ENFORCE(miopenSet4dTensorDescriptor( - top_desc_, miopenTypeWrapper::type, N_out, C_out, H_out, W_out)); + MIOPEN_ENFORCE(miopenSetConvolutionGroupCount( + conv_desc_, group_)); - if (!no_bias_) { MIOPEN_ENFORCE(miopenSet4dTensorDescriptor( - bias_desc_, miopenTypeWrapper::type, 1, M, 1, 1)); - } + weight_desc_, + miopenTypeWrapper::type, + M, + C / group_, + kernel_h(), + kernel_w())); + } + + MIOPEN_ENFORCE(miopenGetConvolutionForwardOutputDim( + conv_desc_, + bottom_desc_, + weight_desc_, + &N_out, + &C_out, + &H_out, + &W_out)); - while ((!bestDataAlgoFound_) && doBwdDataComputation) { + MIOPEN_ENFORCE(miopenSet4dTensorDescriptor( + top_desc_, miopenTypeWrapper::type, N_out, C_out, H_out, W_out)); + + if (!no_bias_) { + MIOPEN_ENFORCE(miopenSet4dTensorDescriptor( + bias_desc_, miopenTypeWrapper::type, 1, M, 1, 1)); + } + + while ((!bestDataAlgoFound_) && doBwdDataComputation) { miopenConvAlgoPerf_t perf; MIOPEN_ENFORCE(miopenConvolutionBackwardDataGetWorkSpaceSize( @@ -489,41 +526,41 @@ bool MIOPENConvGradientOp::DoRunWithType() { bwdDataAlgo_ = perf.bwd_data_algo; } - while (!bestWeightAlgoFound_) { - miopenConvAlgoPerf_t perf; + while (!bestWeightAlgoFound_) { + miopenConvAlgoPerf_t perf; - MIOPEN_ENFORCE(miopenConvolutionBackwardWeightsGetWorkSpaceSize( - miopen_wrapper_.inline_miopen_handle(), - top_desc_, - bottom_desc_, - conv_desc_, - weight_desc_, - &bwdWeightWsSize_)); - if ((bwdWeightWsSize_ > 0) && (bwdWeightWs_ == nullptr)) { - HIP_CHECK(hipMalloc(&bwdWeightWs_, bwdWeightWsSize_)); - } + MIOPEN_ENFORCE(miopenConvolutionBackwardWeightsGetWorkSpaceSize( + miopen_wrapper_.inline_miopen_handle(), + top_desc_, + bottom_desc_, + conv_desc_, + weight_desc_, + &bwdWeightWsSize_)); + if ((bwdWeightWsSize_ > 0) && (bwdWeightWs_ == nullptr)) { + HIP_CHECK(hipMalloc(&bwdWeightWs_, bwdWeightWsSize_)); + } - miopen_wrapper_.with_miopen_state(miopen_state_, [&](MIOPENState* state) { - MIOPEN_ENFORCE(miopenFindConvolutionBackwardWeightsAlgorithm( - state->miopen_handle(), - top_desc_, - dY.template data(), - bottom_desc_, - X.template data(), - conv_desc_, - weight_desc_, - dW->template mutable_data(), - requestAlgoCount_, - &returnedAlgoCount_, - &perf, - bwdWeightWs_, - bwdWeightWsSize_, - false)); - }); - bestWeightAlgoFound_ = true; - bwdWeiAlgo_ = perf.bwd_weights_algo; + miopen_wrapper_.with_miopen_state(miopen_state_, [&](MIOPENState* state) { + MIOPEN_ENFORCE(miopenFindConvolutionBackwardWeightsAlgorithm( + state->miopen_handle(), + top_desc_, + dY.template data(), + bottom_desc_, + X.template data(), + conv_desc_, + weight_desc_, + dW->template mutable_data(), + requestAlgoCount_, + &returnedAlgoCount_, + &perf, + bwdWeightWs_, + bwdWeightWsSize_, + false)); + }); + bestWeightAlgoFound_ = true; + bwdWeiAlgo_ = perf.bwd_weights_algo; + } } - if (doBwdDataComputation) { miopen_wrapper_.with_miopen_state(miopen_state_, [&](MIOPENState* state) { MIOPEN_ENFORCE(miopenConvolutionBackwardData( diff --git a/caffe2/operators/onnx_while_op.h b/caffe2/operators/onnx_while_op.h index 7a3c34cfbf7cce..c6908acb2dddbc 100644 --- a/caffe2/operators/onnx_while_op.h +++ b/caffe2/operators/onnx_while_op.h @@ -27,8 +27,15 @@ class ONNXWhileOp final : public Operator { CAFFE_ENFORCE(!save_scopes_, "Cannot save scopes when disable_scopes=True"); } body_net_def_ = this->template GetSingleArgument("body", NetDef()); + static int64_t counter = -1; if (!body_net_def_.has_name()) { - body_net_def_.set_name("loop_net"); + if (counter == -1) { + ++counter; + body_net_def_.set_name("loop_net"); + } else { + ++counter; + body_net_def_.set_name("loop_net." + caffe2::to_string(counter)); + } } } @@ -50,7 +57,6 @@ class ONNXWhileOp final : public Operator { // and setup a local scope for the first iteration ws_stack_.clear(); auto loop_ws = !disable_scopes_ ? ws_stack_.pushForwardWorkspace(parent_ws_).get() : parent_ws_; - scope_ = std::make_shared(loop_ws, body_net_def_); constexpr int64_t num_inputs_before_lcds = 2; // First input is the maximumt trip count. Second input is the condition @@ -65,6 +71,8 @@ class ONNXWhileOp final : public Operator { int64_t max_trip_count = *Input(0).template data(); const bool first_iter_condition = *Input(1).template data(); + scope_ = std::make_shared(loop_ws, body_net_def_, num_loop_carried_deps); + // Body graph has 1+N+K outputs: recalculated condition variable, N // loop-carried dependencies, and K scan_outputs int num_scan_outputs = @@ -133,7 +141,7 @@ class ONNXWhileOp final : public Operator { cur_output_condition = scope_->template output_condition(); if (save_scopes_) { loop_ws = ws_stack_.pushForwardWorkspace(parent_ws_).get(); - scope_ = std::make_shared(loop_ws, body_net_def_); + scope_ = std::make_shared(loop_ws, body_net_def_, num_loop_carried_deps); } // Copy forward loop-carried dependencies @@ -185,16 +193,9 @@ class ONNXWhileOp final : public Operator { } } - if (scope_->iteration() > 0) { - // Copy out final loop-carried dependencies - for (int i = 0; i < num_loop_carried_deps; ++i) { - Output(i)->CopyFrom(*scope_->lcd_tensor(i)); - } - } else { - // Copy out final loop-carried dependencies - for (int i = 0; i < num_loop_carried_deps; ++i) { - Output(i)->CopyFrom(Input(i + num_inputs_before_lcds)); - } + // Copy out final loop-carried dependencies + for (int i = 0; i < num_loop_carried_deps; ++i) { + Output(i)->CopyFrom(*scope_->lcd_tensor(i)); } return true; @@ -205,13 +206,13 @@ class ONNXWhileOp final : public Operator { public: LocalScope( Workspace *loop_ws, - const NetDef& body_net_def) : loop_ws_(loop_ws) { + const NetDef& body_net_def, size_t num_lcds) : loop_ws_(loop_ws){ CAFFE_ENFORCE(loop_ws_, "Failed to initialize local loop workspace"); // Create loop-carried deps in Workspace lcd_tensors_.clear(); - for (int i = 2; i < body_net_def.external_input_size(); ++i) { + for (int i = 2; i < num_lcds + 2; ++i) { Blob* b = loop_ws_->CreateBlob(body_net_def.external_input(i)); Tensor* t = BlobGetMutableTensor(b, Context::GetDeviceType()); lcd_tensors_.push_back(t); @@ -259,7 +260,7 @@ class ONNXWhileOp final : public Operator { } void set_iteration(int64_t itr) { - iteration_var_->Resize(1); + iteration_var_->Resize(); auto* iteration_var_ptr = iteration_var_->template mutable_data(); *iteration_var_ptr = itr; diff --git a/caffe2/python/onnx/backend.py b/caffe2/python/onnx/backend.py index 7eacaf327ad264..c9ba4935431c76 100644 --- a/caffe2/python/onnx/backend.py +++ b/caffe2/python/onnx/backend.py @@ -568,27 +568,28 @@ def _create_if(cls, init_model, pred_model, n, opset_version): assert ops[0][0].type == 'If' if_op = ops[0][0] then_net = else_net = None + control_inputs = [] for arg in if_op.arg: if arg.name == 'then_net': then_net = arg.n if arg.name == 'else_net': else_net = arg.n + if arg.name == '__control_inputs': + control_inputs = arg.strings + assert then_net and else_net then_net_outs = then_net.external_output else_net_outs = else_net.external_output op_outputs = if_op.output assert len(then_net_outs) == len(else_net_outs) assert len(else_net_outs) == len(op_outputs) - then_net_remap = {} - else_net_remap = {} - # Un-SSA branch outputs - since we're emitting everything into the same - # namespace we don't need the graph output names and the op output - # names to be unique - for then_name, else_name, op_name in zip(then_net_outs, else_net_outs, op_outputs): - then_net_remap[then_name] = op_name - else_net_remap[else_name] = op_name - cls._remove_ssa(then_net, then_net_remap) - cls._remove_ssa(else_net, else_net_remap) + + for arg in if_op.arg: + if arg.name == 'then_net': + arg.n.external_input.extend(control_inputs) + if arg.name == 'else_net': + arg.n.external_input.extend(control_inputs) + return ops @classmethod diff --git a/caffe2/python/onnx/tests/conversion_test.py b/caffe2/python/onnx/tests/conversion_test.py index 311b009cf55b84..911421d86dbf95 100644 --- a/caffe2/python/onnx/tests/conversion_test.py +++ b/caffe2/python/onnx/tests/conversion_test.py @@ -175,10 +175,10 @@ def test_onnx_to_caffe2_zipfile(self): def _make_fake_if_op(self, true_nodes, false_nodes, output_types): true = helper.make_tensor("condition", TensorProto.BOOL, (), [True]) true_graph = helper.make_graph(true_nodes, "true_graph", [], [ - helper.make_tensor_value_info("_Y", TensorProto.FLOAT, (2, 2)), + helper.make_tensor_value_info("Y", TensorProto.FLOAT, (2, 2)), ]) false_graph = helper.make_graph(false_nodes, "false_graph", [], [ - helper.make_tensor_value_info("_Y", TensorProto.FLOAT, (2, 2)), + helper.make_tensor_value_info("Y", TensorProto.FLOAT, (2, 2)), ]) if_inputs = ["condition"] if_outputs = [name for _, _, name in output_types] @@ -191,8 +191,8 @@ def _make_fake_if_op(self, true_nodes, false_nodes, output_types): def test_onnx_to_caffe2_if(self): true_nodes = [helper.make_node( - "MatMul", ["X", "W"], ["_Y"])] - false_nodes = [helper.make_node("Slice", ["X"], ["_Y"], axes=[0, 1], starts=[0, 0], ends=[0, 2])] + "MatMul", ["X", "W"], ["Y"])] + false_nodes = [helper.make_node("Slice", ["X"], ["Y"], axes=[0, 1], starts=[0, 0], ends=[0, 2])] nodes = self._make_fake_if_op(true_nodes, false_nodes, [(TensorProto.FLOAT, (2, 2), "Y")]) X = np.random.rand(2, 3).astype(np.float32) W = np.random.rand(3, 2).flatten().astype(np.float32) diff --git a/caffe2/python/onnx/tests/onnx_backend_test.py b/caffe2/python/onnx/tests/onnx_backend_test.py index ad229a97f807d9..766641ca4916dd 100644 --- a/caffe2/python/onnx/tests/onnx_backend_test.py +++ b/caffe2/python/onnx/tests/onnx_backend_test.py @@ -39,6 +39,7 @@ '|test_mvn.*' # MeanVarianceNormalization is experimental and not supported. '|test_dynamic_slice.*' # MeanVarianceNormalization is experimental and not supported. '|test_constantlike.*' # Needs implementation + '|test_eyelike.*' # Needs implementation ')') # Quick patch to unbreak master CI, is working on the debugging. diff --git a/caffe2/utils/bench_utils.cc b/caffe2/utils/bench_utils.cc index 88894c58dbbf06..df7751285b9996 100644 --- a/caffe2/utils/bench_utils.cc +++ b/caffe2/utils/bench_utils.cc @@ -73,13 +73,14 @@ uint32_t wipe_cache() { break; } #endif - LOG(INFO) << "Allocating cache wipe buffer of size" << wipe_size; + LOG(INFO) << "Allocating cache wipe buffer of size " << wipe_size; wipe_buffer = static_cast(malloc(wipe_size)); CAFFE_ENFORCE(wipe_buffer != nullptr); } uint32_t hash = 0; for (uint32_t i = 0; i * sizeof(uint32_t) < wipe_size; i += 8) { hash ^= wipe_buffer[i]; + wipe_buffer[i] = hash; } /* Make sure compiler doesn't optimize the loop away */ return hash; diff --git a/docs/cpp/source/installing.rst b/docs/cpp/source/installing.rst index 24906dbb53391a..ad662425c32ccd 100644 --- a/docs/cpp/source/installing.rst +++ b/docs/cpp/source/installing.rst @@ -4,7 +4,7 @@ Installing C++ Distributions of PyTorch We provide binary distributions of all headers, libraries and CMake configuration files required to depend on PyTorch. We call this distribution *LibTorch*, and you can download ZIP archives containing the latest LibTorch -distribution on `our website `_. Below +distribution on `our website `_. Below is a small example of writing a minimal application that depends on LibTorch and uses the `at::Tensor` class which comes with the PyTorch C++ API. diff --git a/scripts/fbcode-dev-setup/onnx_c2_setup.sh b/scripts/fbcode-dev-setup/onnx_c2_setup.sh index db6c2745d29aed..92142af267362c 100755 --- a/scripts/fbcode-dev-setup/onnx_c2_setup.sh +++ b/scripts/fbcode-dev-setup/onnx_c2_setup.sh @@ -20,9 +20,10 @@ alias with_proxy="HTTPS_PROXY=http://fwdproxy.any:8080 HTTP_PROXY=http://fwdprox RED='\033[0;31m' CYAN='\033[0;36m' NC='\033[0m' -onnx_root="$HOME/onnx-dev" # I think hardcoding the onnx root dir is fine, just like fbsource +onnx_root="$HOME/local/onnx-dev" # I think hardcoding the onnx root dir is fine, just like fbsource +onnx_root_link="$HOME/onnx-dev" venv="$onnx_root/onnxvenv" -onnx_init_file="$onnx_root/.onnx_env_init" +onnx_init_file="$onnx_root_link/.onnx_env_init" ccache_root="$onnx_root/ccache" ccache_script="$(pwd)/ccache_install.sh" sanity_script="$onnx_root/sanity.sh" @@ -67,6 +68,11 @@ if [ -e "$onnx_root" ]; then mv --backup=t -T "$onnx_root" "${onnx_root}.old.$timestamp" fi mkdir -p "$onnx_root" +if [ -e "$onnx_root_link"]; then + timestamp=$(date "+%Y.%m.%d-%H.%M.%S") + mv --backup=t -T "$onnx_root_link" "${onnx_root_link}.old.$timestamp" +fi +ln -s "$onnx_root" "$onnx_root_link" # Set the name of virtualenv instance with_proxy virtualenv "$venv" @@ -131,48 +137,15 @@ with_proxy git clone https://github.com/pytorch/pytorch --recursive cd "$onnx_root/onnx" with_proxy python setup.py develop -# Build PyTorch +# Build PyTorch and Caffe2 cd "$onnx_root/pytorch" with_proxy pip install -r "requirements.txt" -with_proxy python setup.py build develop - -# Build Caffe2 -set +e +with_proxy python setup.py build_deps develop +# Sanity checks and useful info cd "$onnx_root" with_proxy wget https://raw.githubusercontent.com/pytorch/pytorch/master/scripts/fbcode-dev-setup/onnx_c2_sanity_check.sh -O "$sanity_script" chmod u+x "$sanity_script" - -cd "$onnx_root/pytorch" -with_proxy python setup_caffe2.py develop -caffe2_exit_code=$? -caffe2_ok=true -if [ $caffe2_exit_code != 0 ]; then - caffe2_ok=false -fi -if ! $caffe2_ok; then - # Possible failure reasons when building Caffe2 - ninja_path=$(which ninja) - if [[ ! -z "$ninja_path" ]]; then - echo "${RED}Warning: ninja is installed at $ninja_path, which may cause Caffe2 building issue!!!${NC}" - echo "${RED}Please try to remove the ninja at ${ninja_path}.${NC}" - fi - echo "${RED}We are almost there, only building Caffe2 fails. We can fix this problem seperately.${NC}" - echo "###### Please run the following command before development/fixing the problem: ######" - echo "${CYAN}source $onnx_init_file${NC}" - echo "#####################################################################################" - echo "########## Please run the following command to install Caffe2 seperately: ##########" - echo "${CYAN}cd $onnx_root/pytorch; python setup_caffe2.py develop${NC}" - echo "#####################################################################################" - echo "########### Please run the following command to check your installation: ###########" - echo "${CYAN}$sanity_script${NC}" - echo "#####################################################################################" - exit 1 -fi - -set -e - -# Sanity checks and useful info $sanity_script echo "Congrats, you are ready to rock!!" diff --git a/setup.py b/setup.py index a8cdac91e92369..3b7e2f519ba869 100644 --- a/setup.py +++ b/setup.py @@ -58,7 +58,7 @@ # USE_LEVELDB # enables use of LevelDB for storage # -# USE_LMBD +# USE_LMDB # enables use of LMDB for storage # # BUILD_BINARY @@ -86,6 +86,9 @@ # CUDA_PATH (Windows) # specify where CUDA is installed; usually /usr/local/cuda or # /usr/local/cuda-x.y +# CUDAHOSTCXX +# specify a different compiler than the system one to use as the CUDA +# host compiler for nvcc. # # CUDNN_LIB_DIR # CUDNN_INCLUDE_DIR diff --git a/test/expect/TestBatched.test_for.expect b/test/expect/TestBatched.test_for.expect index 8932957402c94e..6b15b3e7997dea 100644 --- a/test/expect/TestBatched.test_for.expect +++ b/test/expect/TestBatched.test_for.expect @@ -5,7 +5,7 @@ graph(%x.1_data : Dynamic %y_mask : Dynamic %y_dims : Dynamic) { %6 : int = prim::Constant[value=10]() - %7 : int = prim::Constant[value=1]() + %7 : bool = prim::Constant[value=1]() %x : Dynamic, %9 : Dynamic, %10 : Dynamic = prim::Loop(%6, %7, %x.1_data, %x.1_mask, %x.1_dims) block0(%loop_num : int, %5_data : Dynamic, %5_mask : Dynamic, %5_dims : Dynamic) { %15 : int = prim::Constant[value=1]() @@ -14,7 +14,7 @@ graph(%x.1_data : Dynamic %data.1 : Dynamic = aten::add(%5_data, %y_data, %alpha) %mask : Dynamic = aten::mul(%5_mask, %y_mask) %dims : Dynamic = aten::__or__(%5_dims, %y_dims) - %21 : int = prim::Constant[value=1]() + %21 : bool = prim::Constant[value=1]() %data : Dynamic = aten::where(%mask, %data.1, %5_data) -> (%21, %data, %mask, %dims) } diff --git a/test/expect/TestBatched.test_if_else.expect b/test/expect/TestBatched.test_if_else.expect index ddb6763469864b..86475a61e3adae 100644 --- a/test/expect/TestBatched.test_if_else.expect +++ b/test/expect/TestBatched.test_if_else.expect @@ -7,7 +7,7 @@ graph(%a.1_data : Dynamic %6 : Dynamic = aten::gt(%a.1_data, %b_data) %7 : Dynamic = aten::mul(%a.1_mask, %b_mask) %8 : Dynamic = aten::__or__(%a.1_dims, %b_dims) - %9 : int = prim::TensorToNum(%6) + %9 : bool = prim::TensorToBool(%6) %10 : int = prim::Constant[value=1]() %11 : Long() = prim::NumToTensor(%10) %alpha.1 : float = prim::TensorToNum(%11) @@ -24,17 +24,17 @@ graph(%a.1_data : Dynamic %23 : Dynamic = aten::type_as(%7, %6) %cond_mask.1 : Dynamic = aten::mul(%6, %23) %25 : int = aten::dim(%cond_mask.1) - %26 : int = aten::eq(%25, %22) + %26 : bool = aten::eq(%25, %22) %cond_data : Dynamic, %cond_mask : Dynamic, %data : Dynamic = prim::If(%26) block0() { %30 : int = aten::dim(%data.1) %31 : int = aten::sub(%30, %22) - %32 : int = prim::Constant[value=1]() + %32 : bool = prim::Constant[value=1]() %data.3 : Dynamic = prim::Loop(%31, %32, %cond_mask.1) block0(%_ : int, %35 : Dynamic) { %36 : int = aten::dim(%35) %data.2 : Dynamic = aten::unsqueeze(%35, %36) - %38 : int = prim::Constant[value=1]() + %38 : bool = prim::Constant[value=1]() -> (%38, %data.2) } %cond_data.1 : Dynamic = aten::expand_as(%data.3, %data.1) diff --git a/test/expect/TestBatched.test_if_else_with_scalar.expect b/test/expect/TestBatched.test_if_else_with_scalar.expect index 08057e4d10c282..cbe4a9f05bca4b 100644 --- a/test/expect/TestBatched.test_if_else_with_scalar.expect +++ b/test/expect/TestBatched.test_if_else_with_scalar.expect @@ -8,7 +8,7 @@ graph(%a.1_data : Dynamic %7 : Float() = prim::NumToTensor(%6) %other : float = prim::TensorToNum(%7) %9 : Dynamic = aten::gt(%a.1_data, %other) - %10 : int = prim::TensorToNum(%9) + %10 : bool = prim::TensorToBool(%9) %11 : int = prim::Constant[value=1]() %12 : Long() = prim::NumToTensor(%11) %alpha.1 : float = prim::TensorToNum(%12) @@ -25,17 +25,17 @@ graph(%a.1_data : Dynamic %24 : Dynamic = aten::type_as(%a.1_mask, %9) %cond_mask.1 : Dynamic = aten::mul(%9, %24) %26 : int = aten::dim(%cond_mask.1) - %27 : int = aten::eq(%26, %23) + %27 : bool = aten::eq(%26, %23) %cond_data : Dynamic, %cond_mask : Dynamic, %data : Dynamic = prim::If(%27) block0() { %31 : int = aten::dim(%data.1) %32 : int = aten::sub(%31, %23) - %33 : int = prim::Constant[value=1]() + %33 : bool = prim::Constant[value=1]() %data.3 : Dynamic = prim::Loop(%32, %33, %cond_mask.1) block0(%_ : int, %36 : Dynamic) { %37 : int = aten::dim(%36) %data.2 : Dynamic = aten::unsqueeze(%36, %37) - %39 : int = prim::Constant[value=1]() + %39 : bool = prim::Constant[value=1]() -> (%39, %data.2) } %cond_data.1 : Dynamic = aten::expand_as(%data.3, %data.1) diff --git a/test/expect/TestBatched.test_if_noelse.expect b/test/expect/TestBatched.test_if_noelse.expect index a4085639162e6b..8dbed77571217f 100644 --- a/test/expect/TestBatched.test_if_noelse.expect +++ b/test/expect/TestBatched.test_if_noelse.expect @@ -7,7 +7,7 @@ graph(%a.1_data : Dynamic %6 : Dynamic = aten::gt(%a.1_data, %b_data) %7 : Dynamic = aten::mul(%a.1_mask, %b_mask) %8 : Dynamic = aten::__or__(%a.1_dims, %b_dims) - %9 : int = prim::TensorToNum(%6) + %9 : bool = prim::TensorToBool(%6) %10 : int = prim::Constant[value=1]() %11 : Long() = prim::NumToTensor(%10) %alpha : float = prim::TensorToNum(%11) @@ -18,17 +18,17 @@ graph(%a.1_data : Dynamic %17 : Dynamic = aten::type_as(%7, %6) %cond_mask.1 : Dynamic = aten::mul(%6, %17) %19 : int = aten::dim(%cond_mask.1) - %20 : int = aten::eq(%19, %16) + %20 : bool = aten::eq(%19, %16) %cond_data : Dynamic, %cond_mask : Dynamic, %data : Dynamic = prim::If(%20) block0() { %24 : int = aten::dim(%data.1) %25 : int = aten::sub(%24, %16) - %26 : int = prim::Constant[value=1]() + %26 : bool = prim::Constant[value=1]() %data.3 : Dynamic = prim::Loop(%25, %26, %cond_mask.1) block0(%_ : int, %29 : Dynamic) { %30 : int = aten::dim(%29) %data.2 : Dynamic = aten::unsqueeze(%29, %30) - %32 : int = prim::Constant[value=1]() + %32 : bool = prim::Constant[value=1]() -> (%32, %data.2) } %cond_data.1 : Dynamic = aten::expand_as(%data.3, %data.1) diff --git a/test/expect/TestBatched.test_if_noelse_with_scalar.expect b/test/expect/TestBatched.test_if_noelse_with_scalar.expect index 087868ea16bcca..d8f453c9652d7e 100644 --- a/test/expect/TestBatched.test_if_noelse_with_scalar.expect +++ b/test/expect/TestBatched.test_if_noelse_with_scalar.expect @@ -8,7 +8,7 @@ graph(%a.1_data : Dynamic %7 : Float() = prim::NumToTensor(%6) %other : float = prim::TensorToNum(%7) %9 : Dynamic = aten::gt(%a.1_data, %other) - %10 : int = prim::TensorToNum(%9) + %10 : bool = prim::TensorToBool(%9) %11 : int = prim::Constant[value=1]() %12 : Long() = prim::NumToTensor(%11) %alpha : float = prim::TensorToNum(%12) @@ -19,17 +19,17 @@ graph(%a.1_data : Dynamic %18 : Dynamic = aten::type_as(%a.1_mask, %9) %cond_mask.1 : Dynamic = aten::mul(%9, %18) %20 : int = aten::dim(%cond_mask.1) - %21 : int = aten::eq(%20, %17) + %21 : bool = aten::eq(%20, %17) %cond_data : Dynamic, %cond_mask : Dynamic, %data : Dynamic = prim::If(%21) block0() { %25 : int = aten::dim(%data.1) %26 : int = aten::sub(%25, %17) - %27 : int = prim::Constant[value=1]() + %27 : bool = prim::Constant[value=1]() %data.3 : Dynamic = prim::Loop(%26, %27, %cond_mask.1) block0(%_ : int, %30 : Dynamic) { %31 : int = aten::dim(%30) %data.2 : Dynamic = aten::unsqueeze(%30, %31) - %33 : int = prim::Constant[value=1]() + %33 : bool = prim::Constant[value=1]() -> (%33, %data.2) } %cond_data.1 : Dynamic = aten::expand_as(%data.3, %data.1) diff --git a/test/expect/TestBatched.test_while.expect b/test/expect/TestBatched.test_while.expect index 7aba7a89ace320..5cd196b56f3bfb 100644 --- a/test/expect/TestBatched.test_while.expect +++ b/test/expect/TestBatched.test_while.expect @@ -8,12 +8,12 @@ graph(%a.1_data : Dynamic %7 : Dynamic = aten::gt(%a.1_data, %b_data) %8 : Dynamic = aten::mul(%a.1_mask, %b_mask) %9 : Dynamic = aten::__or__(%a.1_dims, %b_dims) - %10 : int = prim::TensorToNum(%7) + %10 : bool = prim::TensorToBool(%7) %11 : int = prim::Constant[value=0]() %12 : Dynamic = aten::mul(%7, %8) %13 : Dynamic = aten::sum(%12) %14 : Dynamic = aten::gt(%13, %11) - %15 : int = prim::TensorToNum(%14) + %15 : bool = prim::TensorToBool(%14) %16 : Dynamic, %17 : Dynamic, %18 : Dynamic, %a : Dynamic, %20 : Dynamic, %21 : Dynamic = prim::Loop(%6, %15, %7, %8, %9, %a.1_data, %a.1_mask, %a.1_dims) block0(%loop_num : int, %cond_data.2 : Dynamic, %cond_mask.3 : Dynamic, %cond_dims : Dynamic, %6_data : Dynamic, %6_mask : Dynamic, %6_dims : Dynamic) { %29 : int = prim::Constant[value=1]() @@ -25,22 +25,22 @@ graph(%a.1_data : Dynamic %35 : Dynamic = aten::gt(%data.1, %b_data) %36 : Dynamic = aten::mul(%mask, %b_mask) %37 : Dynamic = aten::__or__(%dims, %b_dims) - %38 : int = prim::TensorToNum(%35) + %38 : bool = prim::TensorToBool(%35) %39 : int = prim::Constant[value=1]() %40 : Dynamic = aten::type_as(%cond_mask.3, %cond_data.2) %cond_mask.1 : Dynamic = aten::mul(%cond_data.2, %40) %42 : int = aten::dim(%cond_mask.1) - %43 : int = aten::eq(%42, %39) + %43 : bool = aten::eq(%42, %39) %cond_data : Dynamic, %cond_mask : Dynamic, %data : Dynamic = prim::If(%43) block0() { %47 : int = aten::dim(%data.1) %48 : int = aten::sub(%47, %39) - %49 : int = prim::Constant[value=1]() + %49 : bool = prim::Constant[value=1]() %data.3 : Dynamic = prim::Loop(%48, %49, %cond_mask.1) block0(%_ : int, %52 : Dynamic) { %53 : int = aten::dim(%52) %data.2 : Dynamic = aten::unsqueeze(%52, %53) - %55 : int = prim::Constant[value=1]() + %55 : bool = prim::Constant[value=1]() -> (%55, %data.2) } %cond_data.1 : Dynamic = aten::expand_as(%data.3, %data.1) @@ -57,7 +57,7 @@ graph(%a.1_data : Dynamic %62 : Dynamic = aten::mul(%35, %36) %63 : Dynamic = aten::sum(%62) %64 : Dynamic = aten::gt(%63, %61) - %65 : int = prim::TensorToNum(%64) + %65 : bool = prim::TensorToBool(%64) -> (%65, %35, %36, %37, %res_data, %res_mask, %res_dims) } return (%a, %20, %21); diff --git a/test/expect/TestJit.test_batchnorm.expect b/test/expect/TestJit.test_batchnorm.expect index c61390578d45b8..e1fc75d5a42f74 100644 --- a/test/expect/TestJit.test_batchnorm.expect +++ b/test/expect/TestJit.test_batchnorm.expect @@ -4,10 +4,10 @@ graph(%0 : Double(2, 2, 2, 2) %3 : Double(2) %4 : Double(2) %5 : Long()) { - %6 : int = prim::Constant[value=1](), scope: BatchNorm2d + %6 : bool = prim::Constant[value=1](), scope: BatchNorm2d %7 : float = prim::Constant[value=0.1](), scope: BatchNorm2d %8 : float = prim::Constant[value=1e-05](), scope: BatchNorm2d - %9 : int = prim::Constant[value=1](), scope: BatchNorm2d + %9 : bool = prim::Constant[value=1](), scope: BatchNorm2d %10 : Double(2, 2, 2, 2) = aten::batch_norm(%0, %1, %2, %3, %4, %6, %7, %8, %9), scope: BatchNorm2d return (%10); } diff --git a/test/expect/TestJit.test_constant_prop_if_constant.expect b/test/expect/TestJit.test_constant_prop_if_constant.expect index fa1cb8053a3d27..d373c1ee1204b3 100644 --- a/test/expect/TestJit.test_constant_prop_if_constant.expect +++ b/test/expect/TestJit.test_constant_prop_if_constant.expect @@ -1,10 +1,10 @@ graph(%a : Dynamic %b : Dynamic) { %c2.1 : int = prim::Constant[value=1]() - %3 : int = prim::TensorToNum(%a) + %3 : bool = prim::TensorToBool(%a) %c0.4 : int, %c1 : int = prim::If(%3) block0() { - %6 : int = prim::TensorToNum(%b) + %6 : bool = prim::TensorToBool(%b) %c0.3 : int = prim::If(%6) block0() { %8 : int = prim::Constant[value=2]() diff --git a/test/expect/TestJit.test_constant_prop_loop_constant.expect b/test/expect/TestJit.test_constant_prop_loop_constant.expect index d0d4c8ed7ddebe..f5bc3f57205ac3 100644 --- a/test/expect/TestJit.test_constant_prop_loop_constant.expect +++ b/test/expect/TestJit.test_constant_prop_loop_constant.expect @@ -3,16 +3,16 @@ graph() { %b.2 : int = prim::Constant[value=1]() %2 : int = prim::Constant[value=2147483647]() %b.1 : int = prim::Constant[value=0]() - %4 : int = prim::Constant[value=1]() + %4 : bool = prim::Constant[value=1]() %b.3 : int = prim::Loop(%2, %4, %b.1) block0(%6 : int, %7 : int) { - %8 : int = prim::Constant[value=1]() + %8 : bool = prim::Constant[value=1]() -> (%8, %b.2) } - %9 : int = prim::Constant[value=0]() + %9 : bool = prim::Constant[value=0]() %b : int = prim::Loop(%2, %9, %b.3) block0(%11 : int, %12 : int) { - %13 : int = prim::Constant[value=0]() + %13 : bool = prim::Constant[value=0]() -> (%13, %b.4) } return (%b); diff --git a/test/expect/TestJit.test_constant_prop_nested.expect b/test/expect/TestJit.test_constant_prop_nested.expect index 09ef82076edc4a..4a644a0d0036b5 100644 --- a/test/expect/TestJit.test_constant_prop_nested.expect +++ b/test/expect/TestJit.test_constant_prop_nested.expect @@ -1,7 +1,7 @@ graph(%a : Dynamic) { %1 : int = prim::Constant[value=2]() %2 : Dynamic = aten::lt(%a, %1) - %3 : int = prim::TensorToNum(%2) + %3 : bool = prim::TensorToBool(%2) %c : int = prim::If(%3) block0() { %5 : int = prim::Constant[value=5]() diff --git a/test/expect/TestJit.test_conv.expect b/test/expect/TestJit.test_conv.expect index fcb53bad1425dc..20bb0720157af0 100644 --- a/test/expect/TestJit.test_conv.expect +++ b/test/expect/TestJit.test_conv.expect @@ -10,14 +10,14 @@ graph(%0 : Double(20, 16, 50, 40) %9 : int = prim::Constant[value=1](), scope: Conv2d %10 : int = prim::Constant[value=1](), scope: Conv2d %11 : int[] = prim::ListConstruct(%9, %10), scope: Conv2d - %12 : int = prim::Constant[value=0](), scope: Conv2d + %12 : bool = prim::Constant[value=0](), scope: Conv2d %13 : int = prim::Constant[value=0](), scope: Conv2d %14 : int = prim::Constant[value=0](), scope: Conv2d %15 : int[] = prim::ListConstruct(%13, %14), scope: Conv2d %16 : int = prim::Constant[value=1](), scope: Conv2d - %17 : int = prim::Constant[value=0](), scope: Conv2d - %18 : int = prim::Constant[value=0](), scope: Conv2d - %19 : int = prim::Constant[value=1](), scope: Conv2d + %17 : bool = prim::Constant[value=0](), scope: Conv2d + %18 : bool = prim::Constant[value=0](), scope: Conv2d + %19 : bool = prim::Constant[value=1](), scope: Conv2d %20 : Double(20, 13, 48, 38) = aten::_convolution(%0, %1, %2, %5, %8, %11, %12, %15, %16, %17, %18, %19), scope: Conv2d return (%20); } diff --git a/test/expect/TestJit.test_dropout.expect b/test/expect/TestJit.test_dropout.expect index 3daa3484c6e442..3d0d7d312d13d3 100644 --- a/test/expect/TestJit.test_dropout.expect +++ b/test/expect/TestJit.test_dropout.expect @@ -1,6 +1,6 @@ graph(%0 : Double(2, 2)) { %1 : float = prim::Constant[value=0.6](), scope: Dropout - %2 : int = prim::Constant[value=1](), scope: Dropout + %2 : bool = prim::Constant[value=1](), scope: Dropout %3 : Double(2, 2) = aten::dropout(%0, %1, %2), scope: Dropout return (%3); } diff --git a/test/expect/TestJit.test_inplace_copy.expect b/test/expect/TestJit.test_inplace_copy.expect new file mode 100644 index 00000000000000..f046063c9760d6 --- /dev/null +++ b/test/expect/TestJit.test_inplace_copy.expect @@ -0,0 +1,17 @@ +graph(%0 : Double(4, 4)) { + %1 : int = prim::Constant[value=0]() + %2 : int = aten::size(%0, %1) + %3 : Long() = prim::NumToTensor(%2) + %4 : int = prim::TensorToNum(%3) + %5 : int = prim::Constant[value=1]() + %6 : int = aten::size(%0, %5) + %7 : Long() = prim::NumToTensor(%6) + %8 : int = prim::TensorToNum(%7) + %9 : int[] = prim::ListConstruct(%4, %8) + %10 : int = prim::Constant[value=7]() + %11 : int = prim::Constant[value=0]() + %12 : int[] = prim::Constant[value=[0, -1]]() + %13 : Double(4, 4) = aten::zeros(%9, %10, %11, %12) + %14 : Double(4, 4) = aten::expand_as(%0, %13) + return (%14); +} diff --git a/test/expect/TestJit.test_pretty_printer-if_one.expect b/test/expect/TestJit.test_pretty_printer-if_one.expect index 3a9254be45048e..cbede6c812757e 100644 --- a/test/expect/TestJit.test_pretty_printer-if_one.expect +++ b/test/expect/TestJit.test_pretty_printer-if_one.expect @@ -1,6 +1,6 @@ def script(c2, c1): t2 = aten::lt(c2, c1) - t3 = prim::TensorToNum(t2) + t3 = prim::TensorToBool(t2) if t3: c = c2 else: diff --git a/test/expect/TestJit.test_pretty_printer-if_test.expect b/test/expect/TestJit.test_pretty_printer-if_test.expect index 130c9b0c5a8f41..c7e22490788458 100644 --- a/test/expect/TestJit.test_pretty_printer-if_test.expect +++ b/test/expect/TestJit.test_pretty_printer-if_test.expect @@ -1,6 +1,6 @@ def script(c2, c1): t2 = aten::lt(c2, c1) - t3 = prim::TensorToNum(t2) + t3 = prim::TensorToBool(t2) if t3: c = c1 else: diff --git a/test/expect/TestJit.test_pretty_printer-loop_use_test.expect b/test/expect/TestJit.test_pretty_printer-loop_use_test.expect index 4e35ad2150ef58..01934775d836c3 100644 --- a/test/expect/TestJit.test_pretty_printer-loop_use_test.expect +++ b/test/expect/TestJit.test_pretty_printer-loop_use_test.expect @@ -2,14 +2,14 @@ def script(y1): x = aten::add(y1, 1, 1) z1 = aten::add(x, 5, 1) t9 = aten::lt(y1, 8) - t10 = prim::TensorToNum(t9) + t10 = prim::TensorToBool(t9) y = y1 z = z1 t11 = t10 while t11: y2 = aten::add(y, 1, 1) t17 = aten::lt(y2, 8) - t18 = prim::TensorToNum(t17) + t18 = prim::TensorToBool(t17) t11 = t18 y = y2 z = x diff --git a/test/expect/TestJit.test_pretty_printer-while_if_test.expect b/test/expect/TestJit.test_pretty_printer-while_if_test.expect index c830784510e6f3..70d4af6150a795 100644 --- a/test/expect/TestJit.test_pretty_printer-while_if_test.expect +++ b/test/expect/TestJit.test_pretty_printer-while_if_test.expect @@ -1,6 +1,6 @@ def script(a1, b1): t5 = aten::lt(a1, 10) - t6 = prim::TensorToNum(t5) + t6 = prim::TensorToBool(t5) a = a1 b = b1 c = 0 @@ -9,13 +9,13 @@ def script(a1, b1): a2 = aten::add(a, 1, 1) b2 = aten::add(b, 1, 1) t15 = aten::gt(a2, b2) - t16 = prim::TensorToNum(t15) + t16 = prim::TensorToBool(t15) if t16: c4 = 2 else: c4 = 3 t21 = aten::lt(a2, 10) - t22 = prim::TensorToNum(t21) + t22 = prim::TensorToBool(t21) t7 = t22 a = a2 b = b2 diff --git a/test/expect/TestJit.test_pretty_printer-while_test.expect b/test/expect/TestJit.test_pretty_printer-while_test.expect index 487087ad565646..f99e4721f0c347 100644 --- a/test/expect/TestJit.test_pretty_printer-while_test.expect +++ b/test/expect/TestJit.test_pretty_printer-while_test.expect @@ -1,6 +1,6 @@ def script(a1, i1): t4 = aten::lt(i1, 3) - t5 = prim::TensorToNum(t4) + t5 = prim::TensorToBool(t4) a = a1 i = i1 t6 = t5 @@ -8,7 +8,7 @@ def script(a1, i1): a2 = aten::mul(a, a) i2 = aten::add(i, 1, 1) t13 = aten::lt(i2, 3) - t14 = prim::TensorToNum(t13) + t14 = prim::TensorToBool(t13) t6 = t14 a = a2 i = i2 diff --git a/test/expect/TestJit.test_recursive_cse.expect b/test/expect/TestJit.test_recursive_cse.expect index a2aa84b5d65175..dd56a5119362bf 100644 --- a/test/expect/TestJit.test_recursive_cse.expect +++ b/test/expect/TestJit.test_recursive_cse.expect @@ -3,7 +3,7 @@ graph(%z.1 : Dynamic %2 : int = prim::Constant[value=1]() %3 : Dynamic = aten::add(%z.1, %y, %2) %4 : Dynamic = aten::gt(%3, %z.1) - %5 : int = prim::TensorToNum(%4) + %5 : bool = prim::TensorToBool(%4) %z : Dynamic = prim::If(%5) block0() { -> (%3) diff --git a/test/expect/TestScript.test_if_list.expect b/test/expect/TestScript.test_if_list.expect index fddb6a173a2c36..93c942d4dc1eba 100644 --- a/test/expect/TestScript.test_if_list.expect +++ b/test/expect/TestScript.test_if_list.expect @@ -1,5 +1,5 @@ graph(%x : Double(*, *)) { - %1 : int = prim::Constant[value=1]() + %1 : bool = prim::Constant[value=1]() %c : Dynamic[] = prim::If(%1) block0() { %c.1 : Dynamic[] = prim::ListConstruct(%x, %x) diff --git a/test/expect/TestScript.test_if_supertype.expect b/test/expect/TestScript.test_if_supertype.expect index 3b58ca89281ed3..e57f49a27cf67d 100644 --- a/test/expect/TestScript.test_if_supertype.expect +++ b/test/expect/TestScript.test_if_supertype.expect @@ -1,7 +1,7 @@ graph(%y.1 : Float(*, *) %z.2 : Long(*, *) %z.1 : Float(*, *)) { - %3 : int = prim::Constant[value=1]() + %3 : bool = prim::Constant[value=1]() %x : Float(*, *), %y : Dynamic, %z : Dynamic = prim::If(%3) block0() { -> (%y.1, %z.2, %z.1) diff --git a/test/expect/TestScript.test_index_put_trace_with_view.expect b/test/expect/TestScript.test_index_put_trace_with_view.expect index cc03d3d5296d08..12bae3f8b46474 100644 --- a/test/expect/TestScript.test_index_put_trace_with_view.expect +++ b/test/expect/TestScript.test_index_put_trace_with_view.expect @@ -4,7 +4,7 @@ graph(%0 : Double(100) %3 : int = prim::Constant[value=4]() %4 : int[] = prim::ListConstruct(%3) %5 : Double(4) = aten::view(%2, %4) - %6 : int = prim::Constant[value=0]() + %6 : bool = prim::Constant[value=0]() %7 : Long(4) = aten::_cast_Long(%1, %6) %8 : Dynamic[] = prim::ListConstruct(%7) %9 : Double(100) = aten::index_put(%0, %8, %5) diff --git a/test/expect/TestScript.test_index_put_trace_without_view.expect b/test/expect/TestScript.test_index_put_trace_without_view.expect index c72506796064b2..8e5da7efd456ec 100644 --- a/test/expect/TestScript.test_index_put_trace_without_view.expect +++ b/test/expect/TestScript.test_index_put_trace_without_view.expect @@ -1,7 +1,7 @@ graph(%0 : Double(100) %1 : Long(4) %2 : Double(4)) { - %3 : int = prim::Constant[value=0]() + %3 : bool = prim::Constant[value=0]() %4 : Long(4) = aten::_cast_Long(%1, %3) %5 : Dynamic[] = prim::ListConstruct(%4) %6 : Double(100) = aten::index_put(%0, %5, %2) diff --git a/test/expect/TestScript.test_logical_short_circuit.expect b/test/expect/TestScript.test_logical_short_circuit.expect index bcd34a7cb04927..0a4569c2b445b5 100644 --- a/test/expect/TestScript.test_logical_short_circuit.expect +++ b/test/expect/TestScript.test_logical_short_circuit.expect @@ -1,31 +1,31 @@ graph(%t : Dynamic) { %c1.2 : int = prim::Constant[value=0]() %c1.1 : int = prim::Constant[value=1]() - %3 : int = prim::Constant[value=0]() - %4 : int = prim::If(%3) + %3 : bool = prim::Constant[value=0]() + %4 : bool = prim::If(%3) block0() { %5 : int = prim::Constant[value=0]() %6 : Dynamic = aten::select(%t, %5, %c1.1) - %7 : int = prim::TensorToNum(%6) + %7 : bool = prim::TensorToBool(%6) -> (%7) } block1() { -> (%3) } - %8 : int = prim::If(%4) + %8 : bool = prim::If(%4) block0() { -> (%4) } block1() { - %9 : int = prim::Constant[value=1]() - %10 : int = prim::If(%9) + %9 : bool = prim::Constant[value=1]() + %10 : bool = prim::If(%9) block0() { -> (%9) } block1() { %11 : int = prim::Constant[value=0]() %12 : Dynamic = aten::select(%t, %11, %c1.1) - %13 : int = prim::TensorToNum(%12) + %13 : bool = prim::TensorToBool(%12) -> (%13) } -> (%10) diff --git a/test/expect/TestScript.test_loop_unroll_unused_counter.expect b/test/expect/TestScript.test_loop_unroll_unused_counter.expect index 292b251c75da36..feb204a92579b6 100644 --- a/test/expect/TestScript.test_loop_unroll_unused_counter.expect +++ b/test/expect/TestScript.test_loop_unroll_unused_counter.expect @@ -2,7 +2,7 @@ graph(%x : Dynamic) { %1 : int = prim::Constant[value=1]() %y.1 : int = prim::Constant[value=0]() %3 : int = prim::TensorToNum(%x) - %4 : int = prim::Constant[value=1]() + %4 : bool = prim::Constant[value=1]() %5 : int = prim::Constant[value=8]() %6 : int = aten::floordiv(%3, %5) %7 : int = prim::Constant[value=8]() @@ -18,13 +18,13 @@ graph(%x : Dynamic) { %y.9 : int = aten::add(%y.8, %1) %y.10 : int = aten::add(%y.9, %1) %y.11 : int = aten::add(%y.10, %1) - %21 : int = prim::Constant[value=1]() + %21 : bool = prim::Constant[value=1]() -> (%21, %y.11) } %y : int = prim::Loop(%9, %4, %y.3) block0(%i : int, %24 : int) { %y.4 : int = aten::add(%24, %1) - %26 : int = prim::Constant[value=1]() + %26 : bool = prim::Constant[value=1]() -> (%26, %y.4) } return (%y); diff --git a/test/expect/TestScript.test_loop_unrolling.expect b/test/expect/TestScript.test_loop_unrolling.expect index 29546b5c1e9714..5f3e61a4ce34b6 100644 --- a/test/expect/TestScript.test_loop_unrolling.expect +++ b/test/expect/TestScript.test_loop_unrolling.expect @@ -1,7 +1,7 @@ graph(%x : Dynamic) { %y.1 : int = prim::Constant[value=0]() %2 : int = prim::TensorToNum(%x) - %3 : int = prim::Constant[value=1]() + %3 : bool = prim::Constant[value=1]() %4 : int = prim::Constant[value=0]() %5 : int = prim::Constant[value=8]() %6 : int = aten::floordiv(%2, %5) @@ -32,7 +32,7 @@ graph(%x : Dynamic) { %34 : int = prim::Constant[value=1]() %35 : int = aten::add(%32, %34) %y.11 : int = aten::add(%y.10, %35) - %37 : int = prim::Constant[value=1]() + %37 : bool = prim::Constant[value=1]() %38 : int = prim::Constant[value=1]() %39 : int = aten::add(%35, %38) -> (%37, %39, %y.11) @@ -40,7 +40,7 @@ graph(%x : Dynamic) { %40 : Dynamic, %y : int = prim::Loop(%9, %3, %10, %y.3) block0(%i : int, %43 : int, %44 : int) { %y.4 : int = aten::add(%44, %43) - %46 : int = prim::Constant[value=1]() + %46 : bool = prim::Constant[value=1]() %47 : int = prim::Constant[value=1]() %48 : int = aten::add(%43, %47) -> (%46, %48, %y.4) diff --git a/test/expect/TestScript.test_loop_unrolling_nested.expect b/test/expect/TestScript.test_loop_unrolling_nested.expect index a107eb81f72913..2668b111abba9b 100644 --- a/test/expect/TestScript.test_loop_unrolling_nested.expect +++ b/test/expect/TestScript.test_loop_unrolling_nested.expect @@ -1,11 +1,11 @@ graph(%x : Dynamic) { %1 : int = prim::Constant[value=10]() %y.1 : int = prim::Constant[value=0]() - %3 : int = prim::Constant[value=1]() + %3 : bool = prim::Constant[value=1]() %y : int = prim::Loop(%1, %3, %y.1) block0(%i : int, %6 : int) { %7 : int = prim::TensorToNum(%x) - %8 : int = prim::Constant[value=1]() + %8 : bool = prim::Constant[value=1]() %9 : int = prim::Constant[value=0]() %10 : int = prim::Constant[value=8]() %11 : int = aten::floordiv(%7, %10) @@ -36,7 +36,7 @@ graph(%x : Dynamic) { %39 : int = prim::Constant[value=1]() %40 : int = aten::add(%37, %39) %y.12 : int = aten::add(%y.11, %40) - %42 : int = prim::Constant[value=1]() + %42 : bool = prim::Constant[value=1]() %43 : int = prim::Constant[value=1]() %44 : int = aten::add(%40, %43) -> (%42, %44, %y.12) @@ -44,12 +44,12 @@ graph(%x : Dynamic) { %45 : Dynamic, %y.3 : int = prim::Loop(%14, %8, %15, %y.4) block0(%j : int, %48 : int, %49 : int) { %y.5 : int = aten::add(%49, %48) - %51 : int = prim::Constant[value=1]() + %51 : bool = prim::Constant[value=1]() %52 : int = prim::Constant[value=1]() %53 : int = aten::add(%48, %52) -> (%51, %53, %y.5) } - %54 : int = prim::Constant[value=1]() + %54 : bool = prim::Constant[value=1]() -> (%54, %y.3) } return (%y); diff --git a/test/expect/TestScript.test_sum-1.expect b/test/expect/TestScript.test_sum-1.expect index a2bb9d44179580..ce0d1fe0b5d65c 100644 --- a/test/expect/TestScript.test_sum-1.expect +++ b/test/expect/TestScript.test_sum-1.expect @@ -1,7 +1,7 @@ graph(%x : Dynamic) { %1 : int = prim::Constant[value=4]() %2 : int[] = prim::ListConstruct(%1) - %3 : int = prim::Constant[value=0]() + %3 : bool = prim::Constant[value=0]() %4 : Dynamic = aten::sum(%x, %2, %3) return (%4); } diff --git a/test/expect/TestScript.test_sum-2.expect b/test/expect/TestScript.test_sum-2.expect index 4b2352de81fa49..a952901438c94f 100644 --- a/test/expect/TestScript.test_sum-2.expect +++ b/test/expect/TestScript.test_sum-2.expect @@ -1,7 +1,7 @@ graph(%x : Double(*, *, *, *, *)) { %1 : int = prim::Constant[value=4]() %2 : int[] = prim::ListConstruct(%1) - %3 : int = prim::Constant[value=0]() + %3 : bool = prim::Constant[value=0]() %4 : Dynamic = aten::sum(%x, %2, %3) return (%4); } diff --git a/test/expect/TestScript.test_type_cast-float_to_int.expect b/test/expect/TestScript.test_type_cast-test_float_to_int.expect similarity index 76% rename from test/expect/TestScript.test_type_cast-float_to_int.expect rename to test/expect/TestScript.test_type_cast-test_float_to_int.expect index 138b6e49132d28..ffc45ac56552b9 100644 --- a/test/expect/TestScript.test_type_cast-float_to_int.expect +++ b/test/expect/TestScript.test_type_cast-test_float_to_int.expect @@ -1,6 +1,6 @@ graph() { %0 : int = prim::Constant[value=1]() - %1 : float = prim::Constant[value=2]() + %1 : float = prim::Constant[value=5]() %b : int = prim::FloatToInt(%1) %3 : int = aten::add(%b, %0) return (%3); diff --git a/test/expect/TestScript.test_type_cast-int_to_float.expect b/test/expect/TestScript.test_type_cast-test_int_to_float.expect similarity index 100% rename from test/expect/TestScript.test_type_cast-int_to_float.expect rename to test/expect/TestScript.test_type_cast-test_int_to_float.expect diff --git a/test/onnx/test_pytorch_onnx_caffe2.py b/test/onnx/test_pytorch_onnx_caffe2.py index a889e7b1fa0f89..923c0d4c874fc0 100644 --- a/test/onnx/test_pytorch_onnx_caffe2.py +++ b/test/onnx/test_pytorch_onnx_caffe2.py @@ -919,6 +919,15 @@ def forward(self, x): x = torch.rand(5, 5, 5) self.run_model_test(DynamicSliceExportMod(), train=False, input=(x,), batch_size=BATCH_SIZE, use_gpu=False) + def test_tensor_factories(self): + class TensorFactory(torch.nn.Module): + def forward(self, x): + return torch.zeros(x.size()) + torch.ones(x.size()) + + x = torch.randn(2, 3, 4) + self.run_model_test(TensorFactory(), train=False, input=(x,), batch_size=BATCH_SIZE, use_gpu=False) + + # a bit of metaprogramming to set up all the rnn tests diff --git a/test/test_jit.py b/test/test_jit.py index 24d8076d31365f..64b962cd0bf882 100644 --- a/test/test_jit.py +++ b/test/test_jit.py @@ -1365,7 +1365,6 @@ def test_alexnet(self): # as all backwards functions of views are implemented # as a zero filled tensor with a gradient fill on the # viewed portion. - @unittest.expectedFailure def test_inplace_copy(self): x = torch.randn(4, 4, requires_grad=True) @@ -3763,7 +3762,7 @@ def func(a, b): self.checkScript(func, inputs, optimize=True) def test_explicit_bool_cast(self): - with self.assertRaisesRegex(RuntimeError, "expected an integer"): + with self.assertRaisesRegex(RuntimeError, "expected a boolean"): @torch.jit.script def test_bool_cast(a): if a: @@ -3987,18 +3986,38 @@ def throwsAnd(t): throwsAnd(t) def test_type_cast(self): + @torch.jit.script def test_int_to_float(): b = float(2) return b + 1.0 + with self.assertRaisesRegex(RuntimeError, "Cannot cast type"): + @torch.jit.script + def test_int_to_bool(): + return bool(5) + + @torch.jit.script def test_float_to_int(): - b = int(2.0) + b = int(5.0) return b + 1 - graph1 = torch.jit.script(test_int_to_float).graph - self.assertExpectedGraph(graph1, subname="int_to_float") - graph2 = torch.jit.script(test_float_to_int).graph - self.assertExpectedGraph(graph2, subname="float_to_int") + with self.assertRaisesRegex(RuntimeError, "Cannot cast type"): + @torch.jit.script + def test_float_to_bool(): + return bool(5.0) + + with self.assertRaisesRegex(RuntimeError, "Cannot cast type"): + @torch.jit.script + def test_bool_to_float(): + return float(True) + + with self.assertRaisesRegex(RuntimeError, "Cannot cast type"): + @torch.jit.script + def test_bool_to_int(): + return int(True) + + self.assertExpectedGraph(test_int_to_float.graph, "test_int_to_float") + self.assertExpectedGraph(test_float_to_int.graph, "test_float_to_int") def test_multiple_assignment(self): def outer_func(x): @@ -7158,6 +7177,17 @@ def elif_test(niter : int): self.checkScript(code, (101,), name='elif_test', outputs=3028) + def test_python_op_exception(self): + def python_op(x): + raise Exception("bad!") + + @torch.jit.script + def fn(x): + return python_op(x) + + with self.assertRaisesRegex(RuntimeError, "operation failed in interpreter"): + fn(torch.tensor(4)) + class MnistNet(nn.Module): def __init__(self): @@ -7757,27 +7787,6 @@ def forward(self, x, y): # known to be failing in script EXCLUDE_SCRIPT = { - # TODO: Fix var/std - # there are two schemas for var (and std): - # (1) var(Tensor, int, *, bool, bool, Tensor) - # (2) var(Tensor, *, bool) - # - # Right now, the following is happening: - # - Shorter schemas come before longer schemas - # - bool, int are treated as IntType rather than DynamicType like before - # So the schemas look like the following in operator: - # (2) var(DynamicType, IntType) - # (1) var(DynamicType, IntType, IntType, DynamicType) - # Now, when one calls torch.var(tensor, dim=1), the compiler mistakingly - # matches it with (2) instead of (1), which is a problem. - 'test_std_dim', - 'test_std_dim_1d', - 'test_std_dim_1d_neg0', - 'test_std_dim_neg0', - 'test_var_dim', - 'test_var_dim_1d', - 'test_var_dim_1d_neg0', - 'test_var_dim_neg0', 'test_norm_fro', 'test_norm_fro_default', 'test_norm_nuc', diff --git a/test/test_sparse.py b/test/test_sparse.py index 3a13f19e7ecf8b..30796466026b52 100644 --- a/test/test_sparse.py +++ b/test/test_sparse.py @@ -1167,6 +1167,7 @@ def test_log1p(self): device=self.device) self._test_log1p_tensor(input, torch.zeros([5, 6, 0])) + @skipIfRocm def test_sparse_add_coalesce(self): i = self.IndexTensor([[1, 2, 1]]) v = self.ValueTensor([3, 4, 5]) diff --git a/third_party/onnx b/third_party/onnx index c4734c6200cb42..ddf8eb6aa0401f 160000 --- a/third_party/onnx +++ b/third_party/onnx @@ -1 +1 @@ -Subproject commit c4734c6200cb42c1aa36eb1f0160041d2401644d +Subproject commit ddf8eb6aa0401fadea5068391a27413994a672f0 diff --git a/tools/amd_build/pyHIPIFY/cuda_to_hip_mappings.py b/tools/amd_build/pyHIPIFY/cuda_to_hip_mappings.py index 43e2c580a6a61e..b449c4f7f0a1d2 100644 --- a/tools/amd_build/pyHIPIFY/cuda_to_hip_mappings.py +++ b/tools/amd_build/pyHIPIFY/cuda_to_hip_mappings.py @@ -1,3 +1,5 @@ +import collections + from constants import * """ Mapping of CUDA functions, include files, constants, and types to ROCm/HIP equivalents @@ -12,2231 +14,2229 @@ """ # List of math functions that should be replaced inside device code only. -MATH_TRANSPILATIONS = { - "std::max": ("::max"), - "std::min": ("::min"), - "std::ceil": ("::ceil"), - "std::floor": ("::floor"), - "std::exp": ("::exp"), - "std::log": ("::log"), - "std::pow": ("::pow"), - "std::fabs": ("::fabs"), - "std::fmod": ("::fmod"), - "std::remainder": ("::remainder"), -} - +MATH_TRANSPILATIONS = collections.OrderedDict([ + ("std::max", ("::max")), + ("std::min", ("::min")), + ("std::ceil", ("::ceil")), + ("std::floor", ("::floor")), + ("std::exp", ("::exp")), + ("std::log", ("::log")), + ("std::pow", ("::pow")), + ("std::fabs", ("::fabs")), + ("std::fmod", ("::fmod")), + ("std::remainder", ("::remainder")), +]) -CUDA_TYPE_NAME_MAP = { - "CUresult": ("hipError_t", CONV_TYPE, API_DRIVER), - "cudaError_t": ("hipError_t", CONV_TYPE, API_RUNTIME), - "cudaError": ("hipError_t", CONV_TYPE, API_RUNTIME), - "CUDA_ARRAY3D_DESCRIPTOR": ("HIP_ARRAY3D_DESCRIPTOR", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUDA_ARRAY_DESCRIPTOR": ("HIP_ARRAY_DESCRIPTOR", CONV_TYPE, API_DRIVER), - "CUDA_MEMCPY2D": ("hip_Memcpy2D", CONV_TYPE, API_DRIVER), - "CUDA_MEMCPY3D": ("HIP_MEMCPY3D", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUDA_MEMCPY3D_PEER": ("HIP_MEMCPY3D_PEER", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUDA_POINTER_ATTRIBUTE_P2P_TOKENS": ("HIP_POINTER_ATTRIBUTE_P2P_TOKENS", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUDA_RESOURCE_DESC": ("HIP_RESOURCE_DESC", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUDA_RESOURCE_VIEW_DESC": ("HIP_RESOURCE_VIEW_DESC", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUipcEventHandle": ("hipIpcEventHandle", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUipcMemHandle": ("hipIpcMemHandle", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUaddress_mode": ("hipAddress_mode", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUarray_cubemap_face": ("hipArray_cubemap_face", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUarray_format": ("hipArray_format", CONV_TYPE, API_DRIVER), - "CUcomputemode": ("hipComputemode", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUmem_advise": ("hipMemAdvise", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUmem_range_attribute": ("hipMemRangeAttribute", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUctx_flags": ("hipCctx_flags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUdevice": ("hipDevice_t", CONV_TYPE, API_DRIVER), - "CUdevice_attribute_enum": ("hipDeviceAttribute_t", CONV_TYPE, API_DRIVER), - "CUdevice_attribute": ("hipDeviceAttribute_t", CONV_TYPE, API_DRIVER), - "CUdeviceptr": ("hipDeviceptr_t", CONV_TYPE, API_DRIVER), - "CUarray_st": ("hipArray", CONV_TYPE, API_DRIVER), - "CUarray": ("hipArray *", CONV_TYPE, API_DRIVER), - "CUdevprop_st": ("hipDeviceProp_t", CONV_TYPE, API_DRIVER), - "CUdevprop": ("hipDeviceProp_t", CONV_TYPE, API_DRIVER), - "CUfunction": ("hipFunction_t", CONV_TYPE, API_DRIVER), - "CUgraphicsResource": ("hipGraphicsResource_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUmipmappedArray": ("hipMipmappedArray_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUfunction_attribute": ("hipFuncAttribute_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUfunction_attribute_enum": ("hipFuncAttribute_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUgraphicsMapResourceFlags": ("hipGraphicsMapFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUgraphicsMapResourceFlags_enum": ("hipGraphicsMapFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUgraphicsRegisterFlags": ("hipGraphicsRegisterFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUgraphicsRegisterFlags_enum": ("hipGraphicsRegisterFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUoccupancy_flags": ("hipOccupancyFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUoccupancy_flags_enum": ("hipOccupancyFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUfunc_cache_enum": ("hipFuncCache", CONV_TYPE, API_DRIVER), - "CUfunc_cache": ("hipFuncCache", CONV_TYPE, API_DRIVER), - "CUipcMem_flags": ("hipIpcMemFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUipcMem_flags_enum": ("hipIpcMemFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUjit_cacheMode": ("hipJitCacheMode", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CUjit_cacheMode_enum": ("hipJitCacheMode", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CUjit_fallback": ("hipJitFallback", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CUjit_fallback_enum": ("hipJitFallback", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CUjit_option": ("hipJitOption", CONV_JIT, API_DRIVER), - "CUjit_option_enum": ("hipJitOption", CONV_JIT, API_DRIVER), - "CUjit_target": ("hipJitTarget", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CUjit_target_enum": ("hipJitTarget", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CUjitInputType": ("hipJitInputType", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CUjitInputType_enum": ("hipJitInputType", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CUlimit": ("hipLimit_t", CONV_TYPE, API_DRIVER), - "CUlimit_enum": ("hipLimit_t", CONV_TYPE, API_DRIVER), - "CUmemAttach_flags": ("hipMemAttachFlags_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUmemAttach_flags_enum": ("hipMemAttachFlags_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUmemorytype": ("hipMemType_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUmemorytype_enum": ("hipMemType_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUresourcetype": ("hipResourceType", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "CUresourcetype_enum": ("hipResourceType", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "CUresourceViewFormat": ("hipResourceViewFormat", CONV_TEX, API_DRIVER), - "CUresourceViewFormat_enum": ("hipResourceViewFormat", CONV_TEX, API_DRIVER), - "CUsharedconfig": ("hipSharedMemConfig", CONV_TYPE, API_DRIVER), - "CUsharedconfig_enum": ("hipSharedMemConfig", CONV_TYPE, API_DRIVER), - "CUcontext": ("hipCtx_t", CONV_TYPE, API_DRIVER), - "CUmodule": ("hipModule_t", CONV_TYPE, API_DRIVER), - "CUstream": ("hipStream_t", CONV_TYPE, API_DRIVER), - "CUstream_st": ("ihipStream_t", CONV_TYPE, API_DRIVER), - "CUstreamCallback": ("hipStreamCallback_t", CONV_TYPE, API_DRIVER), - "CUsurfObject": ("hipSurfaceObject", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUsurfref": ("hipSurfaceReference_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUtexObject": ("hipTextureObject_t", CONV_TYPE, API_DRIVER), - "CUtexref": ("textureReference", CONV_TYPE, API_DRIVER), - "CUstream_flags": ("hipStreamFlags", CONV_TYPE, API_DRIVER), - "CUstreamWaitValue_flags": ("hipStreamWaitValueFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUstreamWriteValue_flags": ("hipStreamWriteValueFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUstreamBatchMemOpType": ("hipStreamBatchMemOpType", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUdevice_P2PAttribute": ("hipDeviceP2PAttribute", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUevent": ("hipEvent_t", CONV_TYPE, API_DRIVER), - "CUevent_flags": ("hipEventFlags", CONV_EVENT, API_DRIVER, HIP_UNSUPPORTED), - "CUfilter_mode": ("hipTextureFilterMode", CONV_TEX, API_DRIVER), - "CUGLDeviceList": ("hipGLDeviceList", CONV_GL, API_DRIVER, HIP_UNSUPPORTED), - "CUGLmap_flags": ("hipGLMapFlags", CONV_GL, API_DRIVER, HIP_UNSUPPORTED), - "CUd3d9DeviceList": ("hipD3D9DeviceList", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED), - "CUd3d9map_flags": ("hipD3D9MapFlags", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED), - "CUd3d9register_flags": ("hipD3D9RegisterFlags", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED), - "CUd3d10DeviceList": ("hipd3d10DeviceList", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED), - "CUd3d10map_flags": ("hipD3D10MapFlags", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED), - "CUd3d10register_flags": ("hipD3D10RegisterFlags", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED), - "CUd3d11DeviceList": ("hipd3d11DeviceList", CONV_D3D11, API_DRIVER, HIP_UNSUPPORTED), - "CUeglStreamConnection_st": ("hipEglStreamConnection", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED), - "CUeglStreamConnection": ("hipEglStreamConnection", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED), - "libraryPropertyType_t": ("hipLibraryPropertyType_t", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "libraryPropertyType": ("hipLibraryPropertyType_t", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaStreamCallback_t": ("hipStreamCallback_t", CONV_TYPE, API_RUNTIME), - "cudaArray": ("hipArray", CONV_MEM, API_RUNTIME), - "cudaArray_t": ("hipArray_t", CONV_MEM, API_RUNTIME), - "cudaArray_const_t": ("hipArray_const_t", CONV_MEM, API_RUNTIME), - "cudaMipmappedArray_t": ("hipMipmappedArray_t", CONV_MEM, API_RUNTIME), - "cudaMipmappedArray_const_t": ("hipMipmappedArray_const_t", CONV_MEM, API_RUNTIME), - "cudaArrayDefault": ("hipArrayDefault", CONV_MEM, API_RUNTIME), - "cudaArrayLayered": ("hipArrayLayered", CONV_MEM, API_RUNTIME), - "cudaArraySurfaceLoadStore": ("hipArraySurfaceLoadStore", CONV_MEM, API_RUNTIME), - "cudaArrayCubemap": ("hipArrayCubemap", CONV_MEM, API_RUNTIME), - "cudaArrayTextureGather": ("hipArrayTextureGather", CONV_MEM, API_RUNTIME), - "cudaMemoryAdvise": ("hipMemAdvise", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMemRangeAttribute": ("hipMemRangeAttribute", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMemcpyKind": ("hipMemcpyKind", CONV_MEM, API_RUNTIME), - "cudaMemoryType": ("hipMemoryType", CONV_MEM, API_RUNTIME), - "cudaExtent": ("hipExtent", CONV_MEM, API_RUNTIME), - "cudaPitchedPtr": ("hipPitchedPtr", CONV_MEM, API_RUNTIME), - "cudaPos": ("hipPos", CONV_MEM, API_RUNTIME), - "cudaEvent_t": ("hipEvent_t", CONV_TYPE, API_RUNTIME), - "cudaStream_t": ("hipStream_t", CONV_TYPE, API_RUNTIME), - "cudaPointerAttributes": ("hipPointerAttribute_t", CONV_TYPE, API_RUNTIME), - "cudaDeviceAttr": ("hipDeviceAttribute_t", CONV_TYPE, API_RUNTIME), - "cudaDeviceProp": ("hipDeviceProp_t", CONV_TYPE, API_RUNTIME), - "cudaDeviceP2PAttr": ("hipDeviceP2PAttribute", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaComputeMode": ("hipComputeMode", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaFuncCache": ("hipFuncCache_t", CONV_CACHE, API_RUNTIME), - "cudaFuncAttributes": ("hipFuncAttributes", CONV_EXEC, API_RUNTIME, HIP_UNSUPPORTED), - "cudaSharedMemConfig": ("hipSharedMemConfig", CONV_TYPE, API_RUNTIME), - "cudaLimit": ("hipLimit_t", CONV_TYPE, API_RUNTIME), - "cudaOutputMode": ("hipOutputMode", CONV_OTHER, API_RUNTIME, HIP_UNSUPPORTED), - "cudaTextureReadMode": ("hipTextureReadMode", CONV_TEX, API_RUNTIME), - "cudaTextureFilterMode": ("hipTextureFilterMode", CONV_TEX, API_RUNTIME), - "cudaChannelFormatKind": ("hipChannelFormatKind", CONV_TEX, API_RUNTIME), - "cudaChannelFormatDesc": ("hipChannelFormatDesc", CONV_TEX, API_RUNTIME), - "cudaResourceDesc": ("hipResourceDesc", CONV_TEX, API_RUNTIME), - "cudaResourceViewDesc": ("hipResourceViewDesc", CONV_TEX, API_RUNTIME), - "cudaTextureDesc": ("hipTextureDesc", CONV_TEX, API_RUNTIME), - "surfaceReference": ("hipSurfaceReference", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaTextureObject_t": ("hipTextureObject_t", CONV_TEX, API_RUNTIME), - "cudaResourceType": ("hipResourceType", CONV_TEX, API_RUNTIME), - "cudaResourceViewFormat": ("hipResourceViewFormat", CONV_TEX, API_RUNTIME), - "cudaTextureAddressMode": ("hipTextureAddressMode", CONV_TEX, API_RUNTIME), - "cudaSurfaceBoundaryMode": ("hipSurfaceBoundaryMode", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaSurfaceFormatMode": ("hipSurfaceFormatMode", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaTextureType1D": ("hipTextureType1D", CONV_TEX, API_RUNTIME), - "cudaTextureType2D": ("hipTextureType2D", CONV_TEX, API_RUNTIME), - "cudaTextureType3D": ("hipTextureType3D", CONV_TEX, API_RUNTIME), - "cudaTextureTypeCubemap": ("hipTextureTypeCubemap", CONV_TEX, API_RUNTIME), - "cudaTextureType1DLayered": ("hipTextureType1DLayered", CONV_TEX, API_RUNTIME), - "cudaTextureType2DLayered": ("hipTextureType2DLayered", CONV_TEX, API_RUNTIME), - "cudaTextureTypeCubemapLayered": ("hipTextureTypeCubemapLayered", CONV_TEX, API_RUNTIME), - "cudaIpcEventHandle_t": ("hipIpcEventHandle_t", CONV_TYPE, API_RUNTIME), - "cudaIpcEventHandle_st": ("hipIpcEventHandle_t", CONV_TYPE, API_RUNTIME), - "cudaIpcMemHandle_t": ("hipIpcMemHandle_t", CONV_TYPE, API_RUNTIME), - "cudaIpcMemHandle_st": ("hipIpcMemHandle_t", CONV_TYPE, API_RUNTIME), - "cudaGraphicsCubeFace": ("hipGraphicsCubeFace", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsMapFlags": ("hipGraphicsMapFlags", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsRegisterFlags": ("hipGraphicsRegisterFlags", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGLDeviceList": ("hipGLDeviceList", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGLMapFlags": ("hipGLMapFlags", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D9DeviceList": ("hipD3D9DeviceList", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D9MapFlags": ("hipD3D9MapFlags", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D9RegisterFlags": ("hipD3D9RegisterFlags", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D10DeviceList": ("hipd3d10DeviceList", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D10MapFlags": ("hipD3D10MapFlags", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D10RegisterFlags": ("hipD3D10RegisterFlags", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D11DeviceList": ("hipd3d11DeviceList", CONV_D3D11, API_RUNTIME, HIP_UNSUPPORTED), - "cudaEglStreamConnection": ("hipEglStreamConnection", CONV_EGL, API_RUNTIME, HIP_UNSUPPORTED), - "cublasHandle_t": ("rocblas_handle", CONV_TYPE, API_BLAS), - "cublasOperation_t": ("rocblas_operation", CONV_TYPE, API_BLAS), - "cublasStatus_t": ("rocblas_status", CONV_TYPE, API_BLAS), - "cublasFillMode_t": ("rocblas_fill", CONV_TYPE, API_BLAS), - "cublasDiagType_t": ("rocblas_diagonal", CONV_TYPE, API_BLAS), - "cublasSideMode_t": ("rocblas_side", CONV_TYPE, API_BLAS), - "cublasPointerMode_t": ("rocblas_pointer_mode", CONV_TYPE, API_BLAS), - "cublasAtomicsMode_t": ("rocblas_atomics_mode", CONV_TYPE, API_BLAS, HIP_UNSUPPORTED), - "cublasDataType_t": ("rocblas_data_type", CONV_TYPE, API_BLAS, HIP_UNSUPPORTED), - "curandStatus": ("hiprandStatus_t", CONV_TYPE, API_RAND), - "curandStatus_t": ("hiprandStatus_t", CONV_TYPE, API_RAND), - "curandRngType": ("hiprandRngType_t", CONV_TYPE, API_RAND), - "curandRngType_t": ("hiprandRngType_t", CONV_TYPE, API_RAND), - "curandGenerator_st": ("hiprandGenerator_st", CONV_TYPE, API_RAND), - "curandGenerator_t": ("hiprandGenerator_t", CONV_TYPE, API_RAND), - "curandDirectionVectorSet": ("hiprandDirectionVectorSet_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED), - "curandDirectionVectorSet_t": ("hiprandDirectionVectorSet_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED), - "curandOrdering": ("hiprandOrdering_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED), - "curandOrdering_t": ("hiprandOrdering_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED), - "curandDistribution_st": ("hiprandDistribution_st", CONV_TYPE, API_RAND, HIP_UNSUPPORTED), - "curandHistogramM2V_st": ("hiprandDistribution_st", CONV_TYPE, API_RAND, HIP_UNSUPPORTED), - "curandDistribution_t": ("hiprandDistribution_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED), - "curandHistogramM2V_t": ("hiprandDistribution_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED), - "curandDistributionShift_st": ("hiprandDistributionShift_st", CONV_TYPE, API_RAND, HIP_UNSUPPORTED), - "curandDistributionShift_t": ("hiprandDistributionShift_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED), - "curandDistributionM2Shift_st": ("hiprandDistributionM2Shift_st", CONV_TYPE, API_RAND, HIP_UNSUPPORTED), - "curandDistributionM2Shift_t": ("hiprandDistributionM2Shift_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED), - "curandHistogramM2_st": ("hiprandHistogramM2_st", CONV_TYPE, API_RAND, HIP_UNSUPPORTED), - "curandHistogramM2_t": ("hiprandHistogramM2_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED), - "curandHistogramM2K_st": ("hiprandHistogramM2K_st", CONV_TYPE, API_RAND, HIP_UNSUPPORTED), - "curandHistogramM2K_t": ("hiprandHistogramM2K_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED), - "curandDiscreteDistribution_st": ("hiprandDiscreteDistribution_st", CONV_TYPE, API_RAND), - "curandDiscreteDistribution_t": ("hiprandDiscreteDistribution_t", CONV_TYPE, API_RAND), - "curandMethod": ("hiprandMethod_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED), - "curandMethod_t": ("hiprandMethod_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED), - "curandDirectionVectors32_t": ("hiprandDirectionVectors32_t", CONV_TYPE, API_RAND), - "curandDirectionVectors64_t": ("hiprandDirectionVectors64_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED), - "curandStateMtgp32_t": ("hiprandStateMtgp32_t", CONV_TYPE, API_RAND), - "curandStateMtgp32": ("hiprandStateMtgp32_t", CONV_TYPE, API_RAND), - "curandStateScrambledSobol64_t": ("hiprandStateScrambledSobol64_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED), - "curandStateSobol64_t": ("hiprandStateSobol64_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED), - "curandStateScrambledSobol32_t": ("hiprandStateScrambledSobol32_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED), - "curandStateSobol32_t": ("hiprandStateSobol32_t", CONV_TYPE, API_RAND), - "curandStateMRG32k3a_t": ("hiprandStateMRG32k3a_t", CONV_TYPE, API_RAND), - "curandStatePhilox4_32_10_t": ("hiprandStatePhilox4_32_10_t", CONV_TYPE, API_RAND), - "curandStateXORWOW_t": ("hiprandStateXORWOW_t", CONV_TYPE, API_RAND), - "curandState_t": ("hiprandState_t", CONV_TYPE, API_RAND), - "curandState": ("hiprandState_t", CONV_TYPE, API_RAND) -} +CUDA_TYPE_NAME_MAP = collections.OrderedDict([ + ("CUresult", ("hipError_t", CONV_TYPE, API_DRIVER)), + ("cudaError_t", ("hipError_t", CONV_TYPE, API_RUNTIME)), + ("CUDA_ARRAY3D_DESCRIPTOR", ("HIP_ARRAY3D_DESCRIPTOR", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUDA_ARRAY_DESCRIPTOR", ("HIP_ARRAY_DESCRIPTOR", CONV_TYPE, API_DRIVER)), + ("CUDA_MEMCPY2D", ("hip_Memcpy2D", CONV_TYPE, API_DRIVER)), + ("CUDA_MEMCPY3D", ("HIP_MEMCPY3D", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUDA_MEMCPY3D_PEER", ("HIP_MEMCPY3D_PEER", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUDA_POINTER_ATTRIBUTE_P2P_TOKENS", ("HIP_POINTER_ATTRIBUTE_P2P_TOKENS", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUDA_RESOURCE_DESC", ("HIP_RESOURCE_DESC", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUDA_RESOURCE_VIEW_DESC", ("HIP_RESOURCE_VIEW_DESC", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUipcEventHandle", ("hipIpcEventHandle", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUipcMemHandle", ("hipIpcMemHandle", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUaddress_mode", ("hipAddress_mode", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUarray_cubemap_face", ("hipArray_cubemap_face", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUarray_format", ("hipArray_format", CONV_TYPE, API_DRIVER)), + ("CUcomputemode", ("hipComputemode", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUmem_advise", ("hipMemAdvise", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUmem_range_attribute", ("hipMemRangeAttribute", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUctx_flags", ("hipCctx_flags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUdevice", ("hipDevice_t", CONV_TYPE, API_DRIVER)), + ("CUdevice_attribute_enum", ("hipDeviceAttribute_t", CONV_TYPE, API_DRIVER)), + ("CUdevice_attribute", ("hipDeviceAttribute_t", CONV_TYPE, API_DRIVER)), + ("CUdeviceptr", ("hipDeviceptr_t", CONV_TYPE, API_DRIVER)), + ("CUarray_st", ("hipArray", CONV_TYPE, API_DRIVER)), + ("CUarray", ("hipArray *", CONV_TYPE, API_DRIVER)), + ("CUdevprop_st", ("hipDeviceProp_t", CONV_TYPE, API_DRIVER)), + ("CUdevprop", ("hipDeviceProp_t", CONV_TYPE, API_DRIVER)), + ("CUfunction", ("hipFunction_t", CONV_TYPE, API_DRIVER)), + ("CUgraphicsResource", ("hipGraphicsResource_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUmipmappedArray", ("hipMipmappedArray_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUfunction_attribute", ("hipFuncAttribute_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUfunction_attribute_enum", ("hipFuncAttribute_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUgraphicsMapResourceFlags", ("hipGraphicsMapFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUgraphicsMapResourceFlags_enum", ("hipGraphicsMapFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUgraphicsRegisterFlags", ("hipGraphicsRegisterFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUgraphicsRegisterFlags_enum", ("hipGraphicsRegisterFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUoccupancy_flags", ("hipOccupancyFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUoccupancy_flags_enum", ("hipOccupancyFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUfunc_cache_enum", ("hipFuncCache", CONV_TYPE, API_DRIVER)), + ("CUfunc_cache", ("hipFuncCache", CONV_TYPE, API_DRIVER)), + ("CUipcMem_flags", ("hipIpcMemFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUipcMem_flags_enum", ("hipIpcMemFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUjit_cacheMode", ("hipJitCacheMode", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CUjit_cacheMode_enum", ("hipJitCacheMode", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CUjit_fallback", ("hipJitFallback", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CUjit_fallback_enum", ("hipJitFallback", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CUjit_option", ("hipJitOption", CONV_JIT, API_DRIVER)), + ("CUjit_option_enum", ("hipJitOption", CONV_JIT, API_DRIVER)), + ("CUjit_target", ("hipJitTarget", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CUjit_target_enum", ("hipJitTarget", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CUjitInputType", ("hipJitInputType", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CUjitInputType_enum", ("hipJitInputType", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CUlimit", ("hipLimit_t", CONV_TYPE, API_DRIVER)), + ("CUlimit_enum", ("hipLimit_t", CONV_TYPE, API_DRIVER)), + ("CUmemAttach_flags", ("hipMemAttachFlags_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUmemAttach_flags_enum", ("hipMemAttachFlags_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUmemorytype", ("hipMemType_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUmemorytype_enum", ("hipMemType_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUresourcetype", ("hipResourceType", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("CUresourcetype_enum", ("hipResourceType", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("CUresourceViewFormat", ("hipResourceViewFormat", CONV_TEX, API_DRIVER)), + ("CUresourceViewFormat_enum", ("hipResourceViewFormat", CONV_TEX, API_DRIVER)), + ("CUsharedconfig", ("hipSharedMemConfig", CONV_TYPE, API_DRIVER)), + ("CUsharedconfig_enum", ("hipSharedMemConfig", CONV_TYPE, API_DRIVER)), + ("CUcontext", ("hipCtx_t", CONV_TYPE, API_DRIVER)), + ("CUmodule", ("hipModule_t", CONV_TYPE, API_DRIVER)), + ("CUstream", ("hipStream_t", CONV_TYPE, API_DRIVER)), + ("CUstream_st", ("ihipStream_t", CONV_TYPE, API_DRIVER)), + ("CUstreamCallback", ("hipStreamCallback_t", CONV_TYPE, API_DRIVER)), + ("CUsurfObject", ("hipSurfaceObject", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUsurfref", ("hipSurfaceReference_t", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUtexObject", ("hipTextureObject_t", CONV_TYPE, API_DRIVER)), + ("CUtexref", ("textureReference", CONV_TYPE, API_DRIVER)), + ("CUstream_flags", ("hipStreamFlags", CONV_TYPE, API_DRIVER)), + ("CUstreamWaitValue_flags", ("hipStreamWaitValueFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUstreamWriteValue_flags", ("hipStreamWriteValueFlags", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUstreamBatchMemOpType", ("hipStreamBatchMemOpType", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUdevice_P2PAttribute", ("hipDeviceP2PAttribute", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUevent", ("hipEvent_t", CONV_TYPE, API_DRIVER)), + ("CUevent_flags", ("hipEventFlags", CONV_EVENT, API_DRIVER, HIP_UNSUPPORTED)), + ("CUfilter_mode", ("hipTextureFilterMode", CONV_TEX, API_DRIVER)), + ("CUGLDeviceList", ("hipGLDeviceList", CONV_GL, API_DRIVER, HIP_UNSUPPORTED)), + ("CUGLmap_flags", ("hipGLMapFlags", CONV_GL, API_DRIVER, HIP_UNSUPPORTED)), + ("CUd3d9DeviceList", ("hipD3D9DeviceList", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED)), + ("CUd3d9map_flags", ("hipD3D9MapFlags", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED)), + ("CUd3d9register_flags", ("hipD3D9RegisterFlags", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED)), + ("CUd3d10DeviceList", ("hipd3d10DeviceList", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED)), + ("CUd3d10map_flags", ("hipD3D10MapFlags", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED)), + ("CUd3d10register_flags", ("hipD3D10RegisterFlags", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED)), + ("CUd3d11DeviceList", ("hipd3d11DeviceList", CONV_D3D11, API_DRIVER, HIP_UNSUPPORTED)), + ("CUeglStreamConnection_st", ("hipEglStreamConnection", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED)), + ("CUeglStreamConnection", ("hipEglStreamConnection", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED)), + ("libraryPropertyType_t", ("hipLibraryPropertyType_t", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("libraryPropertyType", ("hipLibraryPropertyType_t", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaStreamCallback_t", ("hipStreamCallback_t", CONV_TYPE, API_RUNTIME)), + ("cudaArray", ("hipArray", CONV_MEM, API_RUNTIME)), + ("cudaArray_t", ("hipArray_t", CONV_MEM, API_RUNTIME)), + ("cudaArray_const_t", ("hipArray_const_t", CONV_MEM, API_RUNTIME)), + ("cudaMipmappedArray_t", ("hipMipmappedArray_t", CONV_MEM, API_RUNTIME)), + ("cudaMipmappedArray_const_t", ("hipMipmappedArray_const_t", CONV_MEM, API_RUNTIME)), + ("cudaArrayDefault", ("hipArrayDefault", CONV_MEM, API_RUNTIME)), + ("cudaArrayLayered", ("hipArrayLayered", CONV_MEM, API_RUNTIME)), + ("cudaArraySurfaceLoadStore", ("hipArraySurfaceLoadStore", CONV_MEM, API_RUNTIME)), + ("cudaArrayCubemap", ("hipArrayCubemap", CONV_MEM, API_RUNTIME)), + ("cudaArrayTextureGather", ("hipArrayTextureGather", CONV_MEM, API_RUNTIME)), + ("cudaMemoryAdvise", ("hipMemAdvise", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMemRangeAttribute", ("hipMemRangeAttribute", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMemcpyKind", ("hipMemcpyKind", CONV_MEM, API_RUNTIME)), + ("cudaMemoryType", ("hipMemoryType", CONV_MEM, API_RUNTIME)), + ("cudaExtent", ("hipExtent", CONV_MEM, API_RUNTIME)), + ("cudaPitchedPtr", ("hipPitchedPtr", CONV_MEM, API_RUNTIME)), + ("cudaPos", ("hipPos", CONV_MEM, API_RUNTIME)), + ("cudaEvent_t", ("hipEvent_t", CONV_TYPE, API_RUNTIME)), + ("cudaStream_t", ("hipStream_t", CONV_TYPE, API_RUNTIME)), + ("cudaPointerAttributes", ("hipPointerAttribute_t", CONV_TYPE, API_RUNTIME)), + ("cudaDeviceAttr", ("hipDeviceAttribute_t", CONV_TYPE, API_RUNTIME)), + ("cudaDeviceProp", ("hipDeviceProp_t", CONV_TYPE, API_RUNTIME)), + ("cudaDeviceP2PAttr", ("hipDeviceP2PAttribute", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaComputeMode", ("hipComputeMode", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaFuncCache", ("hipFuncCache_t", CONV_CACHE, API_RUNTIME)), + ("cudaFuncAttributes", ("hipFuncAttributes", CONV_EXEC, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaSharedMemConfig", ("hipSharedMemConfig", CONV_TYPE, API_RUNTIME)), + ("cudaLimit", ("hipLimit_t", CONV_TYPE, API_RUNTIME)), + ("cudaOutputMode", ("hipOutputMode", CONV_OTHER, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaTextureReadMode", ("hipTextureReadMode", CONV_TEX, API_RUNTIME)), + ("cudaTextureFilterMode", ("hipTextureFilterMode", CONV_TEX, API_RUNTIME)), + ("cudaChannelFormatKind", ("hipChannelFormatKind", CONV_TEX, API_RUNTIME)), + ("cudaChannelFormatDesc", ("hipChannelFormatDesc", CONV_TEX, API_RUNTIME)), + ("cudaResourceDesc", ("hipResourceDesc", CONV_TEX, API_RUNTIME)), + ("cudaResourceViewDesc", ("hipResourceViewDesc", CONV_TEX, API_RUNTIME)), + ("cudaTextureDesc", ("hipTextureDesc", CONV_TEX, API_RUNTIME)), + ("surfaceReference", ("hipSurfaceReference", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaTextureObject_t", ("hipTextureObject_t", CONV_TEX, API_RUNTIME)), + ("cudaResourceType", ("hipResourceType", CONV_TEX, API_RUNTIME)), + ("cudaResourceViewFormat", ("hipResourceViewFormat", CONV_TEX, API_RUNTIME)), + ("cudaTextureAddressMode", ("hipTextureAddressMode", CONV_TEX, API_RUNTIME)), + ("cudaSurfaceBoundaryMode", ("hipSurfaceBoundaryMode", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaSurfaceFormatMode", ("hipSurfaceFormatMode", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaTextureType1D", ("hipTextureType1D", CONV_TEX, API_RUNTIME)), + ("cudaTextureType2D", ("hipTextureType2D", CONV_TEX, API_RUNTIME)), + ("cudaTextureType3D", ("hipTextureType3D", CONV_TEX, API_RUNTIME)), + ("cudaTextureTypeCubemap", ("hipTextureTypeCubemap", CONV_TEX, API_RUNTIME)), + ("cudaTextureType1DLayered", ("hipTextureType1DLayered", CONV_TEX, API_RUNTIME)), + ("cudaTextureType2DLayered", ("hipTextureType2DLayered", CONV_TEX, API_RUNTIME)), + ("cudaTextureTypeCubemapLayered", ("hipTextureTypeCubemapLayered", CONV_TEX, API_RUNTIME)), + ("cudaIpcEventHandle_t", ("hipIpcEventHandle_t", CONV_TYPE, API_RUNTIME)), + ("cudaIpcEventHandle_st", ("hipIpcEventHandle_t", CONV_TYPE, API_RUNTIME)), + ("cudaIpcMemHandle_t", ("hipIpcMemHandle_t", CONV_TYPE, API_RUNTIME)), + ("cudaIpcMemHandle_st", ("hipIpcMemHandle_t", CONV_TYPE, API_RUNTIME)), + ("cudaGraphicsCubeFace", ("hipGraphicsCubeFace", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsMapFlags", ("hipGraphicsMapFlags", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsRegisterFlags", ("hipGraphicsRegisterFlags", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGLDeviceList", ("hipGLDeviceList", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGLMapFlags", ("hipGLMapFlags", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D9DeviceList", ("hipD3D9DeviceList", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D9MapFlags", ("hipD3D9MapFlags", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D9RegisterFlags", ("hipD3D9RegisterFlags", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D10DeviceList", ("hipd3d10DeviceList", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D10MapFlags", ("hipD3D10MapFlags", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D10RegisterFlags", ("hipD3D10RegisterFlags", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D11DeviceList", ("hipd3d11DeviceList", CONV_D3D11, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaEglStreamConnection", ("hipEglStreamConnection", CONV_EGL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cublasHandle_t", ("rocblas_handle", CONV_TYPE, API_BLAS)), + ("cublasOperation_t", ("rocblas_operation", CONV_TYPE, API_BLAS)), + ("cublasStatus_t", ("rocblas_status", CONV_TYPE, API_BLAS)), + ("cublasFillMode_t", ("rocblas_fill", CONV_TYPE, API_BLAS)), + ("cublasDiagType_t", ("rocblas_diagonal", CONV_TYPE, API_BLAS)), + ("cublasSideMode_t", ("rocblas_side", CONV_TYPE, API_BLAS)), + ("cublasPointerMode_t", ("rocblas_pointer_mode", CONV_TYPE, API_BLAS)), + ("cublasAtomicsMode_t", ("rocblas_atomics_mode", CONV_TYPE, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDataType_t", ("rocblas_data_type", CONV_TYPE, API_BLAS, HIP_UNSUPPORTED)), + ("curandStatus", ("hiprandStatus_t", CONV_TYPE, API_RAND)), + ("curandStatus_t", ("hiprandStatus_t", CONV_TYPE, API_RAND)), + ("curandRngType", ("hiprandRngType_t", CONV_TYPE, API_RAND)), + ("curandRngType_t", ("hiprandRngType_t", CONV_TYPE, API_RAND)), + ("curandGenerator_st", ("hiprandGenerator_st", CONV_TYPE, API_RAND)), + ("curandGenerator_t", ("hiprandGenerator_t", CONV_TYPE, API_RAND)), + ("curandDirectionVectorSet", ("hiprandDirectionVectorSet_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED)), + ("curandDirectionVectorSet_t", ("hiprandDirectionVectorSet_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED)), + ("curandOrdering", ("hiprandOrdering_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED)), + ("curandOrdering_t", ("hiprandOrdering_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED)), + ("curandDistribution_st", ("hiprandDistribution_st", CONV_TYPE, API_RAND, HIP_UNSUPPORTED)), + ("curandHistogramM2V_st", ("hiprandDistribution_st", CONV_TYPE, API_RAND, HIP_UNSUPPORTED)), + ("curandDistribution_t", ("hiprandDistribution_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED)), + ("curandHistogramM2V_t", ("hiprandDistribution_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED)), + ("curandDistributionShift_st", ("hiprandDistributionShift_st", CONV_TYPE, API_RAND, HIP_UNSUPPORTED)), + ("curandDistributionShift_t", ("hiprandDistributionShift_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED)), + ("curandDistributionM2Shift_st", ("hiprandDistributionM2Shift_st", CONV_TYPE, API_RAND, HIP_UNSUPPORTED)), + ("curandDistributionM2Shift_t", ("hiprandDistributionM2Shift_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED)), + ("curandHistogramM2_st", ("hiprandHistogramM2_st", CONV_TYPE, API_RAND, HIP_UNSUPPORTED)), + ("curandHistogramM2_t", ("hiprandHistogramM2_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED)), + ("curandHistogramM2K_st", ("hiprandHistogramM2K_st", CONV_TYPE, API_RAND, HIP_UNSUPPORTED)), + ("curandHistogramM2K_t", ("hiprandHistogramM2K_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED)), + ("curandDiscreteDistribution_st", ("hiprandDiscreteDistribution_st", CONV_TYPE, API_RAND)), + ("curandDiscreteDistribution_t", ("hiprandDiscreteDistribution_t", CONV_TYPE, API_RAND)), + ("curandMethod", ("hiprandMethod_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED)), + ("curandMethod_t", ("hiprandMethod_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED)), + ("curandDirectionVectors32_t", ("hiprandDirectionVectors32_t", CONV_TYPE, API_RAND)), + ("curandDirectionVectors64_t", ("hiprandDirectionVectors64_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED)), + ("curandStateMtgp32_t", ("hiprandStateMtgp32_t", CONV_TYPE, API_RAND)), + ("curandStateMtgp32", ("hiprandStateMtgp32_t", CONV_TYPE, API_RAND)), + ("curandStateScrambledSobol64_t", ("hiprandStateScrambledSobol64_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED)), + ("curandStateSobol64_t", ("hiprandStateSobol64_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED)), + ("curandStateScrambledSobol32_t", ("hiprandStateScrambledSobol32_t", CONV_TYPE, API_RAND, HIP_UNSUPPORTED)), + ("curandStateSobol32_t", ("hiprandStateSobol32_t", CONV_TYPE, API_RAND)), + ("curandStateMRG32k3a_t", ("hiprandStateMRG32k3a_t", CONV_TYPE, API_RAND)), + ("curandStatePhilox4_32_10_t", ("hiprandStatePhilox4_32_10_t", CONV_TYPE, API_RAND)), + ("curandStateXORWOW_t", ("hiprandStateXORWOW_t", CONV_TYPE, API_RAND)), + ("curandState_t", ("hiprandState_t", CONV_TYPE, API_RAND)), + ("curandState", ("hiprandState_t", CONV_TYPE, API_RAND)), +]) -CUDA_INCLUDE_MAP = { - "cuda.h": ("hip/hip_runtime.h", CONV_INCLUDE_CUDA_MAIN_H, API_DRIVER), - "cuda_runtime.h": ("hip/hip_runtime.h", CONV_INCLUDE_CUDA_MAIN_H, API_RUNTIME), - "cuda_runtime_api.h": ("hip/hip_runtime_api.h", CONV_INCLUDE, API_RUNTIME), - "channel_descriptor.h": ("hip/channel_descriptor.h", CONV_INCLUDE, API_RUNTIME), - "device_functions.h": ("hip/device_functions.h", CONV_INCLUDE, API_RUNTIME), - "driver_types.h": ("hip/driver_types.h", CONV_INCLUDE, API_RUNTIME), - "cuComplex.h": ("hip/hip_complex.h", CONV_INCLUDE, API_RUNTIME), - "cuda_fp16.h": ("hip/hip_fp16.h", CONV_INCLUDE, API_RUNTIME), - "cuda_texture_types.h": ("hip/hip_texture_types.h", CONV_INCLUDE, API_RUNTIME), - "vector_types.h": ("hip/hip_vector_types.h", CONV_INCLUDE, API_RUNTIME), - "cublas.h": ("rocblas.h", CONV_INCLUDE_CUDA_MAIN_H, API_BLAS), - "cublas_v2.h": ("rocblas.h", CONV_INCLUDE_CUDA_MAIN_H, API_BLAS), - "curand.h": ("hiprand.h", CONV_INCLUDE_CUDA_MAIN_H, API_RAND), - "curand_kernel.h": ("hiprand_kernel.h", CONV_INCLUDE, API_RAND), - "curand_discrete.h": ("hiprand_kernel.h", CONV_INCLUDE, API_RAND), - "curand_discrete2.h": ("hiprand_kernel.h", CONV_INCLUDE, API_RAND), - "curand_globals.h": ("hiprand_kernel.h", CONV_INCLUDE, API_RAND), - "curand_lognormal.h": ("hiprand_kernel.h", CONV_INCLUDE, API_RAND), - "curand_mrg32k3a.h": ("hiprand_kernel.h", CONV_INCLUDE, API_RAND), - "curand_mtgp32.h": ("hiprand_kernel.h", CONV_INCLUDE, API_RAND), - "curand_mtgp32_host.h": ("hiprand_mtgp32_host.h", CONV_INCLUDE, API_RAND), - "curand_mtgp32_kernel.h": ("hiprand_kernel.h", CONV_INCLUDE, API_RAND), - "curand_mtgp32dc_p_11213.h": ("rocrand_mtgp32_11213.h", CONV_INCLUDE, API_RAND), - "curand_normal.h": ("hiprand_kernel.h", CONV_INCLUDE, API_RAND), - "curand_normal_static.h": ("hiprand_kernel.h", CONV_INCLUDE, API_RAND), - "curand_philox4x32_x.h": ("hiprand_kernel.h", CONV_INCLUDE, API_RAND), - "curand_poisson.h": ("hiprand_kernel.h", CONV_INCLUDE, API_RAND), - "curand_precalc.h": ("hiprand_kernel.h", CONV_INCLUDE, API_RAND), - "curand_uniform.h": ("hiprand_kernel.h", CONV_INCLUDE, API_RAND), - "cusparse.h": ("hipsparse.h", CONV_INCLUDE, API_RAND), - "cufft.h": ("hipfft.h", CONV_INCLUDE, API_BLAS), - "cufftXt.h": ("hipfft.h", CONV_INCLUDE, API_BLAS), - "#include ": ("", CONV_INCLUDE, API_RAND, HIP_UNSUPPORTED), -} +CUDA_INCLUDE_MAP = collections.OrderedDict([ + ("cuda.h", ("hip/hip_runtime.h", CONV_INCLUDE_CUDA_MAIN_H, API_DRIVER)), + ("cuda_runtime.h", ("hip/hip_runtime.h", CONV_INCLUDE_CUDA_MAIN_H, API_RUNTIME)), + ("cuda_runtime_api.h", ("hip/hip_runtime_api.h", CONV_INCLUDE, API_RUNTIME)), + ("channel_descriptor.h", ("hip/channel_descriptor.h", CONV_INCLUDE, API_RUNTIME)), + ("device_functions.h", ("hip/device_functions.h", CONV_INCLUDE, API_RUNTIME)), + ("driver_types.h", ("hip/driver_types.h", CONV_INCLUDE, API_RUNTIME)), + ("cuComplex.h", ("hip/hip_complex.h", CONV_INCLUDE, API_RUNTIME)), + ("cuda_fp16.h", ("hip/hip_fp16.h", CONV_INCLUDE, API_RUNTIME)), + ("cuda_texture_types.h", ("hip/hip_texture_types.h", CONV_INCLUDE, API_RUNTIME)), + ("vector_types.h", ("hip/hip_vector_types.h", CONV_INCLUDE, API_RUNTIME)), + ("cublas.h", ("rocblas.h", CONV_INCLUDE_CUDA_MAIN_H, API_BLAS)), + ("cublas_v2.h", ("rocblas.h", CONV_INCLUDE_CUDA_MAIN_H, API_BLAS)), + ("curand.h", ("hiprand.h", CONV_INCLUDE_CUDA_MAIN_H, API_RAND)), + ("curand_kernel.h", ("hiprand_kernel.h", CONV_INCLUDE, API_RAND)), + ("curand_discrete.h", ("hiprand_kernel.h", CONV_INCLUDE, API_RAND)), + ("curand_discrete2.h", ("hiprand_kernel.h", CONV_INCLUDE, API_RAND)), + ("curand_globals.h", ("hiprand_kernel.h", CONV_INCLUDE, API_RAND)), + ("curand_lognormal.h", ("hiprand_kernel.h", CONV_INCLUDE, API_RAND)), + ("curand_mrg32k3a.h", ("hiprand_kernel.h", CONV_INCLUDE, API_RAND)), + ("curand_mtgp32.h", ("hiprand_kernel.h", CONV_INCLUDE, API_RAND)), + ("curand_mtgp32_host.h", ("hiprand_mtgp32_host.h", CONV_INCLUDE, API_RAND)), + ("curand_mtgp32_kernel.h", ("hiprand_kernel.h", CONV_INCLUDE, API_RAND)), + ("curand_mtgp32dc_p_11213.h", ("rocrand_mtgp32_11213.h", CONV_INCLUDE, API_RAND)), + ("curand_normal.h", ("hiprand_kernel.h", CONV_INCLUDE, API_RAND)), + ("curand_normal_static.h", ("hiprand_kernel.h", CONV_INCLUDE, API_RAND)), + ("curand_philox4x32_x.h", ("hiprand_kernel.h", CONV_INCLUDE, API_RAND)), + ("curand_poisson.h", ("hiprand_kernel.h", CONV_INCLUDE, API_RAND)), + ("curand_precalc.h", ("hiprand_kernel.h", CONV_INCLUDE, API_RAND)), + ("curand_uniform.h", ("hiprand_kernel.h", CONV_INCLUDE, API_RAND)), + ("cusparse.h", ("hipsparse.h", CONV_INCLUDE, API_RAND)), + ("cufft.h", ("hipfft.h", CONV_INCLUDE, API_BLAS)), + ("cufftXt.h", ("hipfft.h", CONV_INCLUDE, API_BLAS)), + ("#include ", ("", CONV_INCLUDE, API_RAND, HIP_UNSUPPORTED)), +]) -CUDA_IDENTIFIER_MAP = { - "__CUDACC__": ("__HIPCC__", CONV_DEF, API_RUNTIME), - "CUDA_ERROR_INVALID_CONTEXT": ("hipErrorInvalidContext", CONV_TYPE, API_DRIVER), - "CUDA_ERROR_CONTEXT_ALREADY_CURRENT": ("hipErrorContextAlreadyCurrent", CONV_TYPE, API_DRIVER), - "CUDA_ERROR_ARRAY_IS_MAPPED": ("hipErrorArrayIsMapped", CONV_TYPE, API_DRIVER), - "CUDA_ERROR_ALREADY_MAPPED": ("hipErrorAlreadyMapped", CONV_TYPE, API_DRIVER), - "CUDA_ERROR_ALREADY_ACQUIRED": ("hipErrorAlreadyAcquired", CONV_TYPE, API_DRIVER), - "CUDA_ERROR_NOT_MAPPED": ("hipErrorNotMapped", CONV_TYPE, API_DRIVER), - "CUDA_ERROR_NOT_MAPPED_AS_ARRAY": ("hipErrorNotMappedAsArray", CONV_TYPE, API_DRIVER), - "CUDA_ERROR_NOT_MAPPED_AS_POINTER": ("hipErrorNotMappedAsPointer", CONV_TYPE, API_DRIVER), - "CUDA_ERROR_CONTEXT_ALREADY_IN_USE": ("hipErrorContextAlreadyInUse", CONV_TYPE, API_DRIVER), - "CUDA_ERROR_INVALID_SOURCE": ("hipErrorInvalidSource", CONV_TYPE, API_DRIVER), - "CUDA_ERROR_FILE_NOT_FOUND": ("hipErrorFileNotFound", CONV_TYPE, API_DRIVER), - "CUDA_ERROR_NOT_FOUND": ("hipErrorNotFound", CONV_TYPE, API_DRIVER), - "CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING": ("hipErrorLaunchIncompatibleTexturing", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE": ("hipErrorPrimaryContextActive", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUDA_ERROR_CONTEXT_IS_DESTROYED": ("hipErrorContextIsDestroyed", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUDA_ERROR_NOT_PERMITTED": ("hipErrorNotPermitted", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUDA_ERROR_NOT_SUPPORTED": ("hipErrorNotSupported", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "cudaErrorMissingConfiguration": ("hipErrorMissingConfiguration", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorPriorLaunchFailure": ("hipErrorPriorLaunchFailure", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorInvalidDeviceFunction": ("hipErrorInvalidDeviceFunction", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorInvalidConfiguration": ("hipErrorInvalidConfiguration", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorInvalidPitchValue": ("hipErrorInvalidPitchValue", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorInvalidSymbol": ("hipErrorInvalidSymbol", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorInvalidHostPointer": ("hipErrorInvalidHostPointer", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorInvalidDevicePointer": ("hipErrorInvalidDevicePointer", CONV_TYPE, API_RUNTIME), - "cudaErrorInvalidTexture": ("hipErrorInvalidTexture", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorInvalidTextureBinding": ("hipErrorInvalidTextureBinding", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorInvalidChannelDescriptor": ("hipErrorInvalidChannelDescriptor", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorInvalidMemcpyDirection": ("hipErrorInvalidMemcpyDirection", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorAddressOfConstant": ("hipErrorAddressOfConstant", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorTextureFetchFailed": ("hipErrorTextureFetchFailed", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorTextureNotBound": ("hipErrorTextureNotBound", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorSynchronizationError": ("hipErrorSynchronizationError", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorInvalidFilterSetting": ("hipErrorInvalidFilterSetting", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorInvalidNormSetting": ("hipErrorInvalidNormSetting", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorMixedDeviceExecution": ("hipErrorMixedDeviceExecution", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorNotYetImplemented": ("hipErrorNotYetImplemented", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorMemoryValueTooLarge": ("hipErrorMemoryValueTooLarge", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorInsufficientDriver": ("hipErrorInsufficientDriver", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorSetOnActiveProcess": ("hipErrorSetOnActiveProcess", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorInvalidSurface": ("hipErrorInvalidSurface", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorDuplicateVariableName": ("hipErrorDuplicateVariableName", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorDuplicateTextureName": ("hipErrorDuplicateTextureName", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorDuplicateSurfaceName": ("hipErrorDuplicateSurfaceName", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorDevicesUnavailable": ("hipErrorDevicesUnavailable", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorIncompatibleDriverContext": ("hipErrorIncompatibleDriverContext", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorDeviceAlreadyInUse": ("hipErrorDeviceAlreadyInUse", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorLaunchMaxDepthExceeded": ("hipErrorLaunchMaxDepthExceeded", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorLaunchFileScopedTex": ("hipErrorLaunchFileScopedTex", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorLaunchFileScopedSurf": ("hipErrorLaunchFileScopedSurf", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorSyncDepthExceeded": ("hipErrorSyncDepthExceeded", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorLaunchPendingCountExceeded": ("hipErrorLaunchPendingCountExceeded", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorNotPermitted": ("hipErrorNotPermitted", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorNotSupported": ("hipErrorNotSupported", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorStartupFailure": ("hipErrorStartupFailure", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaErrorApiFailureBase": ("hipErrorApiFailureBase", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_SUCCESS": ("hipSuccess", CONV_TYPE, API_DRIVER), - "cudaSuccess": ("hipSuccess", CONV_TYPE, API_RUNTIME), - "CUDA_ERROR_INVALID_VALUE": ("hipErrorInvalidValue", CONV_TYPE, API_DRIVER), - "cudaErrorInvalidValue": ("hipErrorInvalidValue", CONV_TYPE, API_RUNTIME), - "CUDA_ERROR_OUT_OF_MEMORY": ("hipErrorMemoryAllocation", CONV_TYPE, API_DRIVER), - "cudaErrorMemoryAllocation": ("hipErrorMemoryAllocation", CONV_TYPE, API_RUNTIME), - "CUDA_ERROR_NOT_INITIALIZED": ("hipErrorNotInitialized", CONV_TYPE, API_DRIVER), - "cudaErrorInitializationError": ("hipErrorInitializationError", CONV_TYPE, API_RUNTIME), - "CUDA_ERROR_DEINITIALIZED": ("hipErrorDeinitialized", CONV_TYPE, API_DRIVER), - "cudaErrorCudartUnloading": ("hipErrorDeinitialized", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_ERROR_PROFILER_DISABLED": ("hipErrorProfilerDisabled", CONV_TYPE, API_DRIVER), - "cudaErrorProfilerDisabled": ("hipErrorProfilerDisabled", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_ERROR_PROFILER_NOT_INITIALIZED": ("hipErrorProfilerNotInitialized", CONV_TYPE, API_DRIVER), - "cudaErrorProfilerNotInitialized": ("hipErrorProfilerNotInitialized", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_ERROR_PROFILER_ALREADY_STARTED": ("hipErrorProfilerAlreadyStarted", CONV_TYPE, API_DRIVER), - "cudaErrorProfilerAlreadyStarted": ("hipErrorProfilerAlreadyStarted", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_ERROR_PROFILER_ALREADY_STOPPED": ("hipErrorProfilerAlreadyStopped", CONV_TYPE, API_DRIVER), - "cudaErrorProfilerAlreadyStopped": ("hipErrorProfilerAlreadyStopped", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_ERROR_NO_DEVICE": ("hipErrorNoDevice", CONV_TYPE, API_DRIVER), - "cudaErrorNoDevice": ("hipErrorNoDevice", CONV_TYPE, API_RUNTIME), - "CUDA_ERROR_INVALID_DEVICE": ("hipErrorInvalidDevice", CONV_TYPE, API_DRIVER), - "cudaErrorInvalidDevice": ("hipErrorInvalidDevice", CONV_TYPE, API_RUNTIME), - "CUDA_ERROR_INVALID_IMAGE": ("hipErrorInvalidImage", CONV_TYPE, API_DRIVER), - "cudaErrorInvalidKernelImage": ("hipErrorInvalidImage", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_ERROR_MAP_FAILED": ("hipErrorMapFailed", CONV_TYPE, API_DRIVER), - "cudaErrorMapBufferObjectFailed": ("hipErrorMapFailed", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_ERROR_UNMAP_FAILED": ("hipErrorUnmapFailed", CONV_TYPE, API_DRIVER), - "cudaErrorUnmapBufferObjectFailed": ("hipErrorUnmapFailed", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_ERROR_NO_BINARY_FOR_GPU": ("hipErrorNoBinaryForGpu", CONV_TYPE, API_DRIVER), - "cudaErrorNoKernelImageForDevice": ("hipErrorNoBinaryForGpu", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_ERROR_ECC_UNCORRECTABLE": ("hipErrorECCNotCorrectable", CONV_TYPE, API_DRIVER), - "cudaErrorECCUncorrectable": ("hipErrorECCNotCorrectable", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_ERROR_UNSUPPORTED_LIMIT": ("hipErrorUnsupportedLimit", CONV_TYPE, API_DRIVER), - "cudaErrorUnsupportedLimit": ("hipErrorUnsupportedLimit", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_ERROR_PEER_ACCESS_UNSUPPORTED": ("hipErrorPeerAccessUnsupported", CONV_TYPE, API_DRIVER), - "cudaErrorPeerAccessUnsupported": ("hipErrorPeerAccessUnsupported", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_ERROR_INVALID_PTX": ("hipErrorInvalidKernelFile", CONV_TYPE, API_DRIVER), - "cudaErrorInvalidPtx": ("hipErrorInvalidKernelFile", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_ERROR_INVALID_GRAPHICS_CONTEXT": ("hipErrorInvalidGraphicsContext", CONV_TYPE, API_DRIVER), - "cudaErrorInvalidGraphicsContext": ("hipErrorInvalidGraphicsContext", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_ERROR_NVLINK_UNCORRECTABLE": ("hipErrorNvlinkUncorrectable", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "cudaErrorNvlinkUncorrectable": ("hipErrorNvlinkUncorrectable", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND": ("hipErrorSharedObjectSymbolNotFound", CONV_TYPE, API_DRIVER), - "cudaErrorSharedObjectSymbolNotFound": ("hipErrorSharedObjectSymbolNotFound", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_ERROR_SHARED_OBJECT_INIT_FAILED": ("hipErrorSharedObjectInitFailed", CONV_TYPE, API_DRIVER), - "cudaErrorSharedObjectInitFailed": ("hipErrorSharedObjectInitFailed", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_ERROR_OPERATING_SYSTEM": ("hipErrorOperatingSystem", CONV_TYPE, API_DRIVER), - "cudaErrorOperatingSystem": ("hipErrorOperatingSystem", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_ERROR_INVALID_HANDLE": ("hipErrorInvalidResourceHandle", CONV_TYPE, API_DRIVER), - "cudaErrorInvalidResourceHandle": ("hipErrorInvalidResourceHandle", CONV_TYPE, API_RUNTIME), - "CUDA_ERROR_NOT_READY": ("hipErrorNotReady", CONV_TYPE, API_DRIVER), - "cudaErrorNotReady": ("hipErrorNotReady", CONV_TYPE, API_RUNTIME), - "CUDA_ERROR_ILLEGAL_ADDRESS": ("hipErrorIllegalAddress", CONV_TYPE, API_DRIVER), - "cudaErrorIllegalAddress": ("hipErrorIllegalAddress", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES": ("hipErrorLaunchOutOfResources", CONV_TYPE, API_DRIVER), - "cudaErrorLaunchOutOfResources": ("hipErrorLaunchOutOfResources", CONV_TYPE, API_RUNTIME), - "CUDA_ERROR_LAUNCH_TIMEOUT": ("hipErrorLaunchTimeOut", CONV_TYPE, API_DRIVER), - "cudaErrorLaunchTimeout": ("hipErrorLaunchTimeOut", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED": ("hipErrorPeerAccessAlreadyEnabled", CONV_TYPE, API_DRIVER), - "cudaErrorPeerAccessAlreadyEnabled": ("hipErrorPeerAccessAlreadyEnabled", CONV_TYPE, API_RUNTIME), - "CUDA_ERROR_PEER_ACCESS_NOT_ENABLED": ("hipErrorPeerAccessNotEnabled", CONV_TYPE, API_DRIVER), - "cudaErrorPeerAccessNotEnabled": ("hipErrorPeerAccessNotEnabled", CONV_TYPE, API_RUNTIME), - "CUDA_ERROR_ASSERT": ("hipErrorAssert", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "cudaErrorAssert": ("hipErrorAssert", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_ERROR_TOO_MANY_PEERS": ("hipErrorTooManyPeers", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "cudaErrorTooManyPeers": ("hipErrorTooManyPeers", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED": ("hipErrorHostMemoryAlreadyRegistered", CONV_TYPE, API_DRIVER), - "cudaErrorHostMemoryAlreadyRegistered": ("hipErrorHostMemoryAlreadyRegistered", CONV_TYPE, API_RUNTIME), - "CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED": ("hipErrorHostMemoryNotRegistered", CONV_TYPE, API_DRIVER), - "cudaErrorHostMemoryNotRegistered": ("hipErrorHostMemoryNotRegistered", CONV_TYPE, API_RUNTIME), - "CUDA_ERROR_HARDWARE_STACK_ERROR": ("hipErrorHardwareStackError", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "cudaErrorHardwareStackError": ("hipErrorHardwareStackError", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_ERROR_ILLEGAL_INSTRUCTION": ("hipErrorIllegalInstruction", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "cudaErrorIllegalInstruction": ("hipErrorIllegalInstruction", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_ERROR_MISALIGNED_ADDRESS": ("hipErrorMisalignedAddress", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "cudaErrorMisalignedAddress": ("hipErrorMisalignedAddress", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_ERROR_INVALID_ADDRESS_SPACE": ("hipErrorInvalidAddressSpace", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "cudaErrorInvalidAddressSpace": ("hipErrorInvalidAddressSpace", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_ERROR_INVALID_PC": ("hipErrorInvalidPc", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "cudaErrorInvalidPc": ("hipErrorInvalidPc", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_ERROR_LAUNCH_FAILED": ("hipErrorLaunchFailure", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "cudaErrorLaunchFailure": ("hipErrorLaunchFailure", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_ERROR_UNKNOWN": ("hipErrorUnknown", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "cudaErrorUnknown": ("hipErrorUnknown", CONV_TYPE, API_RUNTIME), - "CU_TR_ADDRESS_MODE_WRAP": ("HIP_TR_ADDRESS_MODE_WRAP", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_TR_ADDRESS_MODE_CLAMP": ("HIP_TR_ADDRESS_MODE_CLAMP", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_TR_ADDRESS_MODE_MIRROR": ("HIP_TR_ADDRESS_MODE_MIRROR", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_TR_ADDRESS_MODE_BORDER": ("HIP_TR_ADDRESS_MODE_BORDER", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_CUBEMAP_FACE_POSITIVE_X": ("HIP_CUBEMAP_FACE_POSITIVE_X", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_CUBEMAP_FACE_NEGATIVE_X": ("HIP_CUBEMAP_FACE_NEGATIVE_X", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_CUBEMAP_FACE_POSITIVE_Y": ("HIP_CUBEMAP_FACE_POSITIVE_Y", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_CUBEMAP_FACE_NEGATIVE_Y": ("HIP_CUBEMAP_FACE_NEGATIVE_Y", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_CUBEMAP_FACE_POSITIVE_Z": ("HIP_CUBEMAP_FACE_POSITIVE_Z", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_CUBEMAP_FACE_NEGATIVE_Z": ("HIP_CUBEMAP_FACE_NEGATIVE_Z", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_AD_FORMAT_UNSIGNED_INT8": ("HIP_AD_FORMAT_UNSIGNED_INT8", CONV_TYPE, API_DRIVER), - "CU_AD_FORMAT_UNSIGNED_INT16": ("HIP_AD_FORMAT_UNSIGNED_INT16", CONV_TYPE, API_DRIVER), - "CU_AD_FORMAT_UNSIGNED_INT32": ("HIP_AD_FORMAT_UNSIGNED_INT32", CONV_TYPE, API_DRIVER), - "CU_AD_FORMAT_SIGNED_INT8": ("HIP_AD_FORMAT_SIGNED_INT8", CONV_TYPE, API_DRIVER), - "CU_AD_FORMAT_SIGNED_INT16": ("HIP_AD_FORMAT_SIGNED_INT16", CONV_TYPE, API_DRIVER), - "CU_AD_FORMAT_SIGNED_INT32": ("HIP_AD_FORMAT_SIGNED_INT32", CONV_TYPE, API_DRIVER), - "CU_AD_FORMAT_HALF": ("HIP_AD_FORMAT_HALF", CONV_TYPE, API_DRIVER), - "CU_AD_FORMAT_FLOAT": ("HIP_AD_FORMAT_FLOAT", CONV_TYPE, API_DRIVER), - "CU_COMPUTEMODE_DEFAULT": ("hipComputeModeDefault", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_COMPUTEMODE_EXCLUSIVE": ("hipComputeModeExclusive", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_COMPUTEMODE_PROHIBITED": ("hipComputeModeProhibited", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_COMPUTEMODE_EXCLUSIVE_PROCESS": ("hipComputeModeExclusiveProcess", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_MEM_ADVISE_SET_READ_MOSTLY": ("hipMemAdviseSetReadMostly", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_MEM_ADVISE_UNSET_READ_MOSTLY": ("hipMemAdviseUnsetReadMostly", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_MEM_ADVISE_SET_PREFERRED_LOCATION": ("hipMemAdviseSetPreferredLocation", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_MEM_ADVISE_UNSET_PREFERRED_LOCATION": ("hipMemAdviseUnsetPreferredLocation", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_MEM_ADVISE_SET_ACCESSED_BY": ("hipMemAdviseSetAccessedBy", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_MEM_ADVISE_UNSET_ACCESSED_BY": ("hipMemAdviseUnsetAccessedBy", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY": ("hipMemRangeAttributeReadMostly", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION": ("hipMemRangeAttributePreferredLocation", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY": ("hipMemRangeAttributeAccessedBy", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION": ("hipMemRangeAttributeLastPrefetchLocation", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_CTX_SCHED_AUTO": ("HIP_CTX_SCHED_AUTO", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_CTX_SCHED_SPIN": ("HIP_CTX_SCHED_SPIN", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_CTX_SCHED_YIELD": ("HIP_CTX_SCHED_YIELD", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_CTX_SCHED_BLOCKING_SYNC": ("HIP_CTX_SCHED_BLOCKING_SYNC", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_CTX_BLOCKING_SYNC": ("HIP_CTX_BLOCKING_SYNC", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_CTX_SCHED_MASK": ("HIP_CTX_SCHED_MASK", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_CTX_MAP_HOST": ("HIP_CTX_MAP_HOST", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_CTX_LMEM_RESIZE_TO_MAX": ("HIP_CTX_LMEM_RESIZE_TO_MAX", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_CTX_FLAGS_MASK": ("HIP_CTX_FLAGS_MASK", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_LAUNCH_PARAM_BUFFER_POINTER": ("HIP_LAUNCH_PARAM_BUFFER_POINTER", CONV_TYPE, API_DRIVER), - "CU_LAUNCH_PARAM_BUFFER_SIZE": ("HIP_LAUNCH_PARAM_BUFFER_SIZE", CONV_TYPE, API_DRIVER), - "CU_LAUNCH_PARAM_END": ("HIP_LAUNCH_PARAM_END", CONV_TYPE, API_DRIVER), - "CU_IPC_HANDLE_SIZE": ("HIP_LAUNCH_PARAM_END", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_MEMHOSTALLOC_DEVICEMAP": ("HIP_MEMHOSTALLOC_DEVICEMAP", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_MEMHOSTALLOC_PORTABLE": ("HIP_MEMHOSTALLOC_PORTABLE", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_MEMHOSTALLOC_WRITECOMBINED": ("HIP_MEMHOSTALLOC_WRITECOMBINED", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_MEMHOSTREGISTER_DEVICEMAP": ("HIP_MEMHOSTREGISTER_DEVICEMAP", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_MEMHOSTREGISTER_IOMEMORY": ("HIP_MEMHOSTREGISTER_IOMEMORY", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_MEMHOSTREGISTER_PORTABLE": ("HIP_MEMHOSTREGISTER_PORTABLE", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_PARAM_TR_DEFAULT": ("HIP_PARAM_TR_DEFAULT", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_STREAM_LEGACY": ("HIP_STREAM_LEGACY", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_STREAM_PER_THREAD": ("HIP_STREAM_PER_THREAD", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_TRSA_OVERRIDE_FORMAT": ("HIP_TRSA_OVERRIDE_FORMAT", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_TRSF_NORMALIZED_COORDINATES": ("HIP_TRSF_NORMALIZED_COORDINATES", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_TRSF_READ_AS_INTEGER": ("HIP_TRSF_READ_AS_INTEGER", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_TRSF_SRGB": ("HIP_TRSF_SRGB", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUDA_ARRAY3D_2DARRAY": ("HIP_ARRAY3D_LAYERED", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUDA_ARRAY3D_CUBEMAP": ("HIP_ARRAY3D_CUBEMAP", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUDA_ARRAY3D_DEPTH_TEXTURE": ("HIP_ARRAY3D_DEPTH_TEXTURE", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUDA_ARRAY3D_LAYERED": ("HIP_ARRAY3D_LAYERED", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUDA_ARRAY3D_SURFACE_LDST": ("HIP_ARRAY3D_SURFACE_LDST", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUDA_ARRAY3D_TEXTURE_GATHER": ("HIP_ARRAY3D_TEXTURE_GATHER", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - # "CUDA_VERSION": ("HIP_VERSION", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK": ("hipDeviceAttributeMaxThreadsPerBlock", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X": ("hipDeviceAttributeMaxBlockDimX", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y": ("hipDeviceAttributeMaxBlockDimY", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z": ("hipDeviceAttributeMaxBlockDimZ", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X": ("hipDeviceAttributeMaxGridDimX", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y": ("hipDeviceAttributeMaxGridDimY", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z": ("hipDeviceAttributeMaxGridDimZ", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK": ("hipDeviceAttributeMaxSharedMemoryPerBlock", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK": ("hipDeviceAttributeMaxSharedMemoryPerBlock", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY": ("hipDeviceAttributeTotalConstantMemory", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_WARP_SIZE": ("hipDeviceAttributeWarpSize", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAX_PITCH": ("hipDeviceAttributeMaxPitch", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK": ("hipDeviceAttributeMaxRegistersPerBlock", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK": ("hipDeviceAttributeMaxRegistersPerBlock", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_CLOCK_RATE": ("hipDeviceAttributeClockRate", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT": ("hipDeviceAttributeTextureAlignment", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_GPU_OVERLAP": ("hipDeviceAttributeAsyncEngineCount", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT": ("hipDeviceAttributeMultiprocessorCount", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT": ("hipDeviceAttributeKernelExecTimeout", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_INTEGRATED": ("hipDeviceAttributeIntegrated", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY": ("hipDeviceAttributeCanMapHostMemory", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_COMPUTE_MODE": ("hipDeviceAttributeComputeMode", CONV_TYPE, API_DRIVER), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH": ("hipDeviceAttributeMaxTexture1DWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH": ("hipDeviceAttributeMaxTexture2DWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT": ("hipDeviceAttributeMaxTexture2DHeight", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH": ("hipDeviceAttributeMaxTexture3DWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT": ("hipDeviceAttributeMaxTexture3DHeight", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH": ("hipDeviceAttributeMaxTexture3DDepth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH": ("hipDeviceAttributeMaxTexture2DLayeredWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT": ("hipDeviceAttributeMaxTexture2DLayeredHeight", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS": ("hipDeviceAttributeMaxTexture2DLayeredLayers", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_WIDTH": ("hipDeviceAttributeMaxTexture2DLayeredWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_HEIGHT": ("hipDeviceAttributeMaxTexture2DLayeredHeight", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES": ("hipDeviceAttributeMaxTexture2DLayeredLayers", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT": ("hipDeviceAttributeSurfaceAlignment", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS": ("hipDeviceAttributeConcurrentKernels", CONV_TYPE, API_DRIVER), - "CU_DEVICE_ATTRIBUTE_ECC_ENABLED": ("hipDeviceAttributeEccEnabled", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_PCI_BUS_ID": ("hipDeviceAttributePciBusId", CONV_TYPE, API_DRIVER), - "CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID": ("hipDeviceAttributePciDeviceId", CONV_TYPE, API_DRIVER), - "CU_DEVICE_ATTRIBUTE_TCC_DRIVER": ("hipDeviceAttributeTccDriver", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE": ("hipDeviceAttributeMemoryClockRate", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH": ("hipDeviceAttributeMemoryBusWidth", CONV_TYPE, API_DRIVER), - "CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE": ("hipDeviceAttributeL2CacheSize", CONV_TYPE, API_DRIVER), - "CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR": ("hipDeviceAttributeMaxThreadsPerMultiProcessor", CONV_TYPE, API_DRIVER), - "CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT": ("hipDeviceAttributeAsyncEngineCount", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING": ("hipDeviceAttributeUnifiedAddressing", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH": ("hipDeviceAttributeMaxTexture1DLayeredWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS": ("hipDeviceAttributeMaxTexture1DLayeredLayers", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_CAN_TEX2D_GATHER": ("hipDeviceAttributeCanTex2DGather", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_WIDTH": ("hipDeviceAttributeMaxTexture2DGatherWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_HEIGHT": ("hipDeviceAttributeMaxTexture2DGatherHeight", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE": ("hipDeviceAttributeMaxTexture3DWidthAlternate", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE": ("hipDeviceAttributeMaxTexture3DHeightAlternate", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE": ("hipDeviceAttributeMaxTexture3DDepthAlternate", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID": ("hipDeviceAttributePciDomainId", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT": ("hipDeviceAttributeTexturePitchAlignment", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_WIDTH": ("hipDeviceAttributeMaxTextureCubemapWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH": ("hipDeviceAttributeMaxTextureCubemapLayeredWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS": ("hipDeviceAttributeMaxTextureCubemapLayeredLayers", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_WIDTH": ("hipDeviceAttributeMaxSurface1DWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_WIDTH": ("hipDeviceAttributeMaxSurface2DWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_HEIGHT": ("hipDeviceAttributeMaxSurface2DHeight", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_WIDTH": ("hipDeviceAttributeMaxSurface3DWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_HEIGHT": ("hipDeviceAttributeMaxSurface3DHeight", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_DEPTH": ("hipDeviceAttributeMaxSurface3DDepth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_WIDTH": ("hipDeviceAttributeMaxSurface1DLayeredWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_LAYERS": ("hipDeviceAttributeMaxSurface1DLayeredLayers", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_WIDTH": ("hipDeviceAttributeMaxSurface2DLayeredWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_HEIGHT": ("hipDeviceAttributeMaxSurface2DLayeredHeight", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_LAYERS": ("hipDeviceAttributeMaxSurface2DLayeredLayers", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_WIDTH": ("hipDeviceAttributeMaxSurfaceCubemapWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_WIDTH": ("hipDeviceAttributeMaxSurfaceCubemapLayeredWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_LAYERS": ("hipDeviceAttributeMaxSurfaceCubemapLayeredLayers", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH": ("hipDeviceAttributeMaxTexture1DLinearWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH": ("hipDeviceAttributeMaxTexture2DLinearWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT": ("hipDeviceAttributeMaxTexture2DLinearHeight", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH": ("hipDeviceAttributeMaxTexture2DLinearPitch", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH": ("hipDeviceAttributeMaxTexture2DMipmappedWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_HEIGHT": ("hipDeviceAttributeMaxTexture2DMipmappedHeight", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR": ("hipDeviceAttributeComputeCapabilityMajor", CONV_TYPE, API_DRIVER), - "CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR": ("hipDeviceAttributeComputeCapabilityMinor", CONV_TYPE, API_DRIVER), - "CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH": ("hipDeviceAttributeMaxTexture1DMipmappedWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_STREAM_PRIORITIES_SUPPORTED": ("hipDeviceAttributeStreamPrioritiesSupported", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED": ("hipDeviceAttributeGlobalL1CacheSupported", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED": ("hipDeviceAttributeLocalL1CacheSupported", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR": ("hipDeviceAttributeMaxSharedMemoryPerMultiprocessor", CONV_TYPE, API_DRIVER), - "CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR": ("hipDeviceAttributeMaxRegistersPerMultiprocessor", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY": ("hipDeviceAttributeManagedMemory", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD": ("hipDeviceAttributeIsMultiGpuBoard", CONV_TYPE, API_DRIVER), - "CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID": ("hipDeviceAttributeMultiGpuBoardGroupId", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED": ("hipDeviceAttributeHostNativeAtomicSupported", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO": ("hipDeviceAttributeSingleToDoublePrecisionPerfRatio", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS": ("hipDeviceAttributePageableMemoryAccess", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS": ("hipDeviceAttributeConcurrentManagedAccess", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED": ("hipDeviceAttributeComputePreemptionSupported", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM": ("hipDeviceAttributeCanUseHostPointerForRegisteredMem", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_ATTRIBUTE_MAX": ("hipDeviceAttributeMax", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_POINTER_ATTRIBUTE_CONTEXT": ("hipPointerAttributeContext", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_POINTER_ATTRIBUTE_MEMORY_TYPE": ("hipPointerAttributeMemoryType", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_POINTER_ATTRIBUTE_DEVICE_POINTER": ("hipPointerAttributeDevicePointer", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_POINTER_ATTRIBUTE_HOST_POINTER": ("hipPointerAttributeHostPointer", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_POINTER_ATTRIBUTE_P2P_TOKENS": ("hipPointerAttributeP2pTokens", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_POINTER_ATTRIBUTE_SYNC_MEMOPS": ("hipPointerAttributeSyncMemops", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_POINTER_ATTRIBUTE_BUFFER_ID": ("hipPointerAttributeBufferId", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_POINTER_ATTRIBUTE_IS_MANAGED": ("hipPointerAttributeIsManaged", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK": ("hipFuncAttributeMaxThreadsPerBlocks", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES": ("hipFuncAttributeSharedSizeBytes", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES": ("hipFuncAttributeConstSizeBytes", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES": ("hipFuncAttributeLocalSizeBytes", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_FUNC_ATTRIBUTE_NUM_REGS": ("hipFuncAttributeNumRegs", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_FUNC_ATTRIBUTE_PTX_VERSION": ("hipFuncAttributePtxVersion", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_FUNC_ATTRIBUTE_BINARY_VERSION": ("hipFuncAttributeBinaryVersion", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_FUNC_ATTRIBUTE_CACHE_MODE_CA": ("hipFuncAttributeCacheModeCA", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_FUNC_ATTRIBUTE_MAX": ("hipFuncAttributeMax", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE": ("hipGraphicsMapFlagsNone", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY": ("hipGraphicsMapFlagsReadOnly", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD": ("hipGraphicsMapFlagsWriteDiscard", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_GRAPHICS_REGISTER_FLAGS_NONE": ("hipGraphicsRegisterFlagsNone", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_GRAPHICS_REGISTER_FLAGS_READ_ONLY": ("hipGraphicsRegisterFlagsReadOnly", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_GRAPHICS_REGISTER_FLAGS_WRITE_DISCARD": ("hipGraphicsRegisterFlagsWriteDiscard", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_GRAPHICS_REGISTER_FLAGS_SURFACE_LDST": ("hipGraphicsRegisterFlagsSurfaceLoadStore", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_GRAPHICS_REGISTER_FLAGS_TEXTURE_GATHER": ("hipGraphicsRegisterFlagsTextureGather", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_OCCUPANCY_DEFAULT": ("hipOccupancyDefault", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE": ("hipOccupancyDisableCachingOverride", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_FUNC_CACHE_PREFER_NONE": ("hipFuncCachePreferNone", CONV_CACHE, API_DRIVER), - "CU_FUNC_CACHE_PREFER_SHARED": ("hipFuncCachePreferShared", CONV_CACHE, API_DRIVER), - "CU_FUNC_CACHE_PREFER_L1": ("hipFuncCachePreferL1", CONV_CACHE, API_DRIVER), - "CU_FUNC_CACHE_PREFER_EQUAL": ("hipFuncCachePreferEqual", CONV_CACHE, API_DRIVER), - "CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESS": ("hipIpcMemLazyEnablePeerAccess", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CUDA_IPC_HANDLE_SIZE": ("HIP_IPC_HANDLE_SIZE", CONV_TYPE, API_DRIVER), - "CU_JIT_CACHE_OPTION_NONE": ("hipJitCacheModeOptionNone", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CU_JIT_CACHE_OPTION_CG": ("hipJitCacheModeOptionCG", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CU_JIT_CACHE_OPTION_CA": ("hipJitCacheModeOptionCA", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CU_PREFER_PTX": ("hipJitFallbackPreferPtx", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CU_PREFER_BINARY": ("hipJitFallbackPreferBinary", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CU_JIT_MAX_REGISTERS": ("hipJitOptionMaxRegisters", CONV_JIT, API_DRIVER), - "CU_JIT_THREADS_PER_BLOCK": ("hipJitOptionThreadsPerBlock", CONV_JIT, API_DRIVER), - "CU_JIT_WALL_TIME": ("hipJitOptionWallTime", CONV_JIT, API_DRIVER), - "CU_JIT_INFO_LOG_BUFFER": ("hipJitOptionInfoLogBuffer", CONV_JIT, API_DRIVER), - "CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES": ("hipJitOptionInfoLogBufferSizeBytes", CONV_JIT, API_DRIVER), - "CU_JIT_ERROR_LOG_BUFFER": ("hipJitOptionErrorLogBuffer", CONV_JIT, API_DRIVER), - "CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES": ("hipJitOptionErrorLogBufferSizeBytes", CONV_JIT, API_DRIVER), - "CU_JIT_OPTIMIZATION_LEVEL": ("hipJitOptionOptimizationLevel", CONV_JIT, API_DRIVER), - "CU_JIT_TARGET_FROM_CUCONTEXT": ("hipJitOptionTargetFromContext", CONV_JIT, API_DRIVER), - "CU_JIT_TARGET": ("hipJitOptionTarget", CONV_JIT, API_DRIVER), - "CU_JIT_FALLBACK_STRATEGY": ("hipJitOptionFallbackStrategy", CONV_JIT, API_DRIVER), - "CU_JIT_GENERATE_DEBUG_INFO": ("hipJitOptionGenerateDebugInfo", CONV_JIT, API_DRIVER), - "CU_JIT_LOG_VERBOSE": ("hipJitOptionLogVerbose", CONV_JIT, API_DRIVER), - "CU_JIT_GENERATE_LINE_INFO": ("hipJitOptionGenerateLineInfo", CONV_JIT, API_DRIVER), - "CU_JIT_CACHE_MODE": ("hipJitOptionCacheMode", CONV_JIT, API_DRIVER), - "CU_JIT_NEW_SM3X_OPT": ("hipJitOptionSm3xOpt", CONV_JIT, API_DRIVER), - "CU_JIT_FAST_COMPILE": ("hipJitOptionFastCompile", CONV_JIT, API_DRIVER), - "CU_JIT_NUM_OPTIONS": ("hipJitOptionNumOptions", CONV_JIT, API_DRIVER), - "CU_TARGET_COMPUTE_10": ("hipJitTargetCompute10", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CU_TARGET_COMPUTE_11": ("hipJitTargetCompute11", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CU_TARGET_COMPUTE_12": ("hipJitTargetCompute12", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CU_TARGET_COMPUTE_13": ("hipJitTargetCompute13", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CU_TARGET_COMPUTE_20": ("hipJitTargetCompute20", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CU_TARGET_COMPUTE_21": ("hipJitTargetCompute21", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CU_TARGET_COMPUTE_30": ("hipJitTargetCompute30", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CU_TARGET_COMPUTE_32": ("hipJitTargetCompute32", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CU_TARGET_COMPUTE_35": ("hipJitTargetCompute35", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CU_TARGET_COMPUTE_37": ("hipJitTargetCompute37", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CU_TARGET_COMPUTE_50": ("hipJitTargetCompute50", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CU_TARGET_COMPUTE_52": ("hipJitTargetCompute52", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CU_TARGET_COMPUTE_53": ("hipJitTargetCompute53", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CU_TARGET_COMPUTE_60": ("hipJitTargetCompute60", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CU_TARGET_COMPUTE_61": ("hipJitTargetCompute61", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CU_TARGET_COMPUTE_62": ("hipJitTargetCompute62", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CU_JIT_INPUT_CUBIN": ("hipJitInputTypeBin", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CU_JIT_INPUT_PTX": ("hipJitInputTypePtx", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CU_JIT_INPUT_FATBINARY": ("hipJitInputTypeFatBinary", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CU_JIT_INPUT_OBJECT": ("hipJitInputTypeObject", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CU_JIT_INPUT_LIBRARY": ("hipJitInputTypeLibrary", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CU_JIT_NUM_INPUT_TYPES": ("hipJitInputTypeNumInputTypes", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED), - "CU_LIMIT_STACK_SIZE": ("hipLimitStackSize", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_LIMIT_PRINTF_FIFO_SIZE": ("hipLimitPrintfFifoSize", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_LIMIT_MALLOC_HEAP_SIZE": ("hipLimitMallocHeapSize", CONV_TYPE, API_DRIVER), - "CU_LIMIT_DEV_RUNTIME_SYNC_DEPTH": ("hipLimitDevRuntimeSyncDepth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_LIMIT_DEV_RUNTIME_PENDING_LAUNCH_COUNT": ("hipLimitDevRuntimePendingLaunchCount", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_LIMIT_STACK_SIZE": ("hipLimitStackSize", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_MEM_ATTACH_GLOBAL": ("hipMemAttachGlobal", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_MEM_ATTACH_HOST": ("hipMemAttachHost", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_MEM_ATTACH_SINGLE": ("hipMemAttachSingle", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_MEMORYTYPE_HOST": ("hipMemTypeHost", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_MEMORYTYPE_DEVICE": ("hipMemTypeDevice", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_MEMORYTYPE_ARRAY": ("hipMemTypeArray", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_MEMORYTYPE_UNIFIED": ("hipMemTypeUnified", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_RESOURCE_TYPE_ARRAY": ("hipResourceTypeArray", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "CU_RESOURCE_TYPE_MIPMAPPED_ARRAY": ("hipResourceTypeMipmappedArray", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "CU_RESOURCE_TYPE_LINEAR": ("hipResourceTypeLinear", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "CU_RESOURCE_TYPE_PITCH2D": ("hipResourceTypePitch2D", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "CU_RES_VIEW_FORMAT_NONE": ("hipResViewFormatNone", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_UINT_1X8": ("hipResViewFormatUnsignedChar1", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_UINT_2X8": ("hipResViewFormatUnsignedChar2", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_UINT_4X8": ("hipResViewFormatUnsignedChar4", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_SINT_1X8": ("hipResViewFormatSignedChar1", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_SINT_2X8": ("hipResViewFormatSignedChar2", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_SINT_4X8": ("hipResViewFormatSignedChar4", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_UINT_1X16": ("hipResViewFormatUnsignedShort1", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_UINT_2X16": ("hipResViewFormatUnsignedShort2", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_UINT_4X16": ("hipResViewFormatUnsignedShort4", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_SINT_1X16": ("hipResViewFormatSignedShort1", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_SINT_2X16": ("hipResViewFormatSignedShort2", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_SINT_4X16": ("hipResViewFormatSignedShort4", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_UINT_1X32": ("hipResViewFormatUnsignedInt1", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_UINT_2X32": ("hipResViewFormatUnsignedInt2", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_UINT_4X32": ("hipResViewFormatUnsignedInt4", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_SINT_1X32": ("hipResViewFormatSignedInt1", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_SINT_2X32": ("hipResViewFormatSignedInt2", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_SINT_4X32": ("hipResViewFormatSignedInt4", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_FLOAT_1X16": ("hipResViewFormatHalf1", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_FLOAT_2X16": ("hipResViewFormatHalf2", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_FLOAT_4X16": ("hipResViewFormatHalf4", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_FLOAT_1X32": ("hipResViewFormatFloat1", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_FLOAT_2X32": ("hipResViewFormatFloat2", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_FLOAT_4X32": ("hipResViewFormatFloat4", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_UNSIGNED_BC1": ("hipResViewFormatUnsignedBlockCompressed1", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_UNSIGNED_BC2": ("hipResViewFormatUnsignedBlockCompressed2", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_UNSIGNED_BC3": ("hipResViewFormatUnsignedBlockCompressed3", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_UNSIGNED_BC4": ("hipResViewFormatUnsignedBlockCompressed4", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_SIGNED_BC4": ("hipResViewFormatSignedBlockCompressed4", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_UNSIGNED_BC5": ("hipResViewFormatUnsignedBlockCompressed5", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_SIGNED_BC5": ("hipResViewFormatSignedBlockCompressed5", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_UNSIGNED_BC6H": ("hipResViewFormatUnsignedBlockCompressed6H", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_SIGNED_BC6H": ("hipResViewFormatSignedBlockCompressed6H", CONV_TEX, API_DRIVER), - "CU_RES_VIEW_FORMAT_UNSIGNED_BC7": ("hipResViewFormatUnsignedBlockCompressed7", CONV_TEX, API_DRIVER), - "CU_SHARED_MEM_CONFIG_DEFAULT_BANK_SIZE": ("hipSharedMemBankSizeDefault", CONV_TYPE, API_DRIVER), - "CU_SHARED_MEM_CONFIG_FOUR_BYTE_BANK_SIZE": ("hipSharedMemBankSizeFourByte", CONV_TYPE, API_DRIVER), - "CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE": ("hipSharedMemBankSizeEightByte", CONV_TYPE, API_DRIVER), - "CU_STREAM_DEFAULT": ("hipStreamDefault", CONV_TYPE, API_DRIVER), - "CU_STREAM_NON_BLOCKING": ("hipStreamNonBlocking", CONV_TYPE, API_DRIVER), - "CU_STREAM_WAIT_VALUE_GEQ": ("hipStreamWaitValueGeq", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_STREAM_WAIT_VALUE_EQ": ("hipStreamWaitValueEq", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_STREAM_WAIT_VALUE_AND": ("hipStreamWaitValueAnd", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_STREAM_WAIT_VALUE_FLUSH": ("hipStreamWaitValueFlush", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_STREAM_WRITE_VALUE_DEFAULT": ("hipStreamWriteValueDefault", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_STREAM_WRITE_VALUE_NO_MEMORY_BARRIER": ("hipStreamWriteValueNoMemoryBarrier", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_STREAM_MEM_OP_WAIT_VALUE_32": ("hipStreamBatchMemOpWaitValue32", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_STREAM_MEM_OP_WRITE_VALUE_32": ("hipStreamBatchMemOpWriteValue32", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES": ("hipStreamBatchMemOpFlushRemoteWrites", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "cuGetErrorName": ("hipGetErrorName___", CONV_ERROR, API_DRIVER, HIP_UNSUPPORTED), - "cuGetErrorString": ("hipGetErrorString___", CONV_ERROR, API_DRIVER, HIP_UNSUPPORTED), - "cuInit": ("hipInit", CONV_INIT, API_DRIVER), - "cuDriverGetVersion": ("hipDriverGetVersion", CONV_VERSION, API_DRIVER), - "cuCtxCreate_v2": ("hipCtxCreate", CONV_CONTEXT, API_DRIVER), - "cuCtxDestroy_v2": ("hipCtxDestroy", CONV_CONTEXT, API_DRIVER), - "cuCtxGetApiVersion": ("hipCtxGetApiVersion", CONV_CONTEXT, API_DRIVER), - "cuCtxGetCacheConfig": ("hipCtxGetCacheConfig", CONV_CONTEXT, API_DRIVER), - "cuCtxGetCurrent": ("hipCtxGetCurrent", CONV_CONTEXT, API_DRIVER), - "cuCtxGetDevice": ("hipCtxGetDevice", CONV_CONTEXT, API_DRIVER), - "cuCtxGetFlags": ("hipCtxGetFlags", CONV_CONTEXT, API_DRIVER), - "cuCtxGetLimit": ("hipCtxGetLimit", CONV_CONTEXT, API_DRIVER, HIP_UNSUPPORTED), - "cuCtxGetSharedMemConfig": ("hipCtxGetSharedMemConfig", CONV_CONTEXT, API_DRIVER), - "cuCtxGetStreamPriorityRange": ("hipCtxGetStreamPriorityRange", CONV_CONTEXT, API_DRIVER, HIP_UNSUPPORTED), - "cuCtxPopCurrent_v2": ("hipCtxPopCurrent", CONV_CONTEXT, API_DRIVER), - "cuCtxPushCurrent_v2": ("hipCtxPushCurrent", CONV_CONTEXT, API_DRIVER), - "cuCtxSetCacheConfig": ("hipCtxSetCacheConfig", CONV_CONTEXT, API_DRIVER), - "cuCtxSetCurrent": ("hipCtxSetCurrent", CONV_CONTEXT, API_DRIVER), - "cuCtxSetLimit": ("hipCtxSetLimit", CONV_CONTEXT, API_DRIVER, HIP_UNSUPPORTED), - "cuCtxSetSharedMemConfig": ("hipCtxSetSharedMemConfig", CONV_CONTEXT, API_DRIVER), - "cuCtxSynchronize": ("hipCtxSynchronize", CONV_CONTEXT, API_DRIVER), - "cuCtxAttach": ("hipCtxAttach", CONV_CONTEXT, API_DRIVER, HIP_UNSUPPORTED), - "cuCtxDetach": ("hipCtxDetach", CONV_CONTEXT, API_DRIVER, HIP_UNSUPPORTED), - "cuCtxEnablePeerAccess": ("hipCtxEnablePeerAccess", CONV_PEER, API_DRIVER), - "cuCtxDisablePeerAccess": ("hipCtxDisablePeerAccess", CONV_PEER, API_DRIVER), - "cuDeviceCanAccessPeer": ("hipDeviceCanAccessPeer", CONV_PEER, API_DRIVER), - "cuDeviceGetP2PAttribute": ("hipDeviceGetP2PAttribute", CONV_PEER, API_DRIVER, HIP_UNSUPPORTED), - "cuDevicePrimaryCtxGetState": ("hipDevicePrimaryCtxGetState", CONV_CONTEXT, API_DRIVER), - "cuDevicePrimaryCtxRelease": ("hipDevicePrimaryCtxRelease", CONV_CONTEXT, API_DRIVER), - "cuDevicePrimaryCtxReset": ("hipDevicePrimaryCtxReset", CONV_CONTEXT, API_DRIVER), - "cuDevicePrimaryCtxRetain": ("hipDevicePrimaryCtxRetain", CONV_CONTEXT, API_DRIVER), - "cuDevicePrimaryCtxSetFlags": ("hipDevicePrimaryCtxSetFlags", CONV_CONTEXT, API_DRIVER), - "cuDeviceGet": ("hipGetDevice", CONV_DEVICE, API_DRIVER), - "cuDeviceGetName": ("hipDeviceGetName", CONV_DEVICE, API_DRIVER), - "cuDeviceGetCount": ("hipGetDeviceCount", CONV_DEVICE, API_DRIVER), - "cuDeviceGetAttribute": ("hipDeviceGetAttribute", CONV_DEVICE, API_DRIVER), - "cuDeviceGetPCIBusId": ("hipDeviceGetPCIBusId", CONV_DEVICE, API_DRIVER), - "cuDeviceGetByPCIBusId": ("hipDeviceGetByPCIBusId", CONV_DEVICE, API_DRIVER), - "cuDeviceTotalMem_v2": ("hipDeviceTotalMem", CONV_DEVICE, API_DRIVER), - "cuDeviceComputeCapability": ("hipDeviceComputeCapability", CONV_DEVICE, API_DRIVER), - "cuDeviceGetProperties": ("hipGetDeviceProperties", CONV_DEVICE, API_DRIVER), - "cuLinkAddData": ("hipLinkAddData", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED), - "cuLinkAddFile": ("hipLinkAddFile", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED), - "cuLinkComplete": ("hipLinkComplete", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED), - "cuLinkCreate": ("hipLinkCreate", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED), - "cuLinkDestroy": ("hipLinkDestroy", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED), - "cuModuleGetFunction": ("hipModuleGetFunction", CONV_MODULE, API_DRIVER), - "cuModuleGetGlobal_v2": ("hipModuleGetGlobal", CONV_MODULE, API_DRIVER), - "cuModuleGetSurfRef": ("hipModuleGetSurfRef", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED), - "cuModuleGetTexRef": ("hipModuleGetTexRef", CONV_MODULE, API_DRIVER), - "cuModuleLoad": ("hipModuleLoad", CONV_MODULE, API_DRIVER), - "cuModuleLoadData": ("hipModuleLoadData", CONV_MODULE, API_DRIVER), - "cuModuleLoadDataEx": ("hipModuleLoadDataEx", CONV_MODULE, API_DRIVER), - "cuModuleLoadFatBinary": ("hipModuleLoadFatBinary", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED), - "cuModuleUnload": ("hipModuleUnload", CONV_MODULE, API_DRIVER), - "CU_DEVICE_P2P_ATTRIBUTE_PERFORMANCE_RANK": ("hipDeviceP2PAttributePerformanceRank", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_P2P_ATTRIBUTE_ACCESS_SUPPORTED": ("hipDeviceP2PAttributeAccessSupported", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_DEVICE_P2P_ATTRIBUTE_NATIVE_ATOMIC_SUPPORTED": ("hipDeviceP2PAttributeNativeAtomicSupported", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED), - "CU_EVENT_DEFAULT": ("hipEventDefault", CONV_EVENT, API_DRIVER), - "CU_EVENT_BLOCKING_SYNC": ("hipEventBlockingSync", CONV_EVENT, API_DRIVER), - "CU_EVENT_DISABLE_TIMING": ("hipEventDisableTiming", CONV_EVENT, API_DRIVER), - "CU_EVENT_INTERPROCESS": ("hipEventInterprocess", CONV_EVENT, API_DRIVER), - "cuEventCreate": ("hipEventCreate", CONV_EVENT, API_DRIVER), - "cuEventDestroy_v2": ("hipEventDestroy", CONV_EVENT, API_DRIVER), - "cuEventElapsedTime": ("hipEventElapsedTime", CONV_EVENT, API_DRIVER), - "cuEventQuery": ("hipEventQuery", CONV_EVENT, API_DRIVER), - "cuEventRecord": ("hipEventRecord", CONV_EVENT, API_DRIVER), - "cuEventSynchronize": ("hipEventSynchronize", CONV_EVENT, API_DRIVER), - "cuFuncGetAttribute": ("hipFuncGetAttribute", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED), - "cuFuncSetCacheConfig": ("hipFuncSetCacheConfig", CONV_MODULE, API_DRIVER), - "cuFuncSetSharedMemConfig": ("hipFuncSetSharedMemConfig", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED), - "cuLaunchKernel": ("hipModuleLaunchKernel", CONV_MODULE, API_DRIVER), - "cuFuncSetBlockShape": ("hipFuncSetBlockShape", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED), - "cuFuncSetSharedSize": ("hipFuncSetSharedSize", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED), - "cuLaunch": ("hipLaunch", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED), - "cuLaunchGrid": ("hipLaunchGrid", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED), - "cuLaunchGridAsync": ("hipLaunchGridAsync", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED), - "cuParamSetf": ("hipParamSetf", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED), - "cuParamSeti": ("hipParamSeti", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED), - "cuParamSetSize": ("hipParamSetSize", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED), - "cuParamSetSize": ("hipParamSetSize", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED), - "cuParamSetv": ("hipParamSetv", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED), - "cuOccupancyMaxActiveBlocksPerMultiprocessor": ("hipOccupancyMaxActiveBlocksPerMultiprocessor", CONV_OCCUPANCY, API_DRIVER), - "cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags": ("hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags", CONV_OCCUPANCY, API_DRIVER, HIP_UNSUPPORTED), - "cuOccupancyMaxPotentialBlockSize": ("hipOccupancyMaxPotentialBlockSize", CONV_OCCUPANCY, API_DRIVER), - "cuOccupancyMaxPotentialBlockSizeWithFlags": ("hipOccupancyMaxPotentialBlockSizeWithFlags", CONV_OCCUPANCY, API_DRIVER, HIP_UNSUPPORTED), - "cuStreamAddCallback": ("hipStreamAddCallback", CONV_STREAM, API_DRIVER), - "cuStreamAttachMemAsync": ("hipStreamAttachMemAsync", CONV_STREAM, API_DRIVER, HIP_UNSUPPORTED), - "cuStreamCreate": ("hipStreamCreate__", CONV_STREAM, API_DRIVER, HIP_UNSUPPORTED), - "cuStreamCreateWithPriority": ("hipStreamCreateWithPriority", CONV_STREAM, API_DRIVER, HIP_UNSUPPORTED), - "cuStreamDestroy_v2": ("hipStreamDestroy", CONV_STREAM, API_DRIVER), - "cuStreamGetFlags": ("hipStreamGetFlags", CONV_STREAM, API_DRIVER), - "cuStreamGetPriority": ("hipStreamGetPriority", CONV_STREAM, API_DRIVER, HIP_UNSUPPORTED), - "cuStreamQuery": ("hipStreamQuery", CONV_STREAM, API_DRIVER), - "cuStreamSynchronize": ("hipStreamSynchronize", CONV_STREAM, API_DRIVER), - "cuStreamWaitEvent": ("hipStreamWaitEvent", CONV_STREAM, API_DRIVER), - "cuStreamWaitValue32": ("hipStreamWaitValue32", CONV_STREAM, API_DRIVER, HIP_UNSUPPORTED), - "cuStreamWriteValue32": ("hipStreamWriteValue32", CONV_STREAM, API_DRIVER, HIP_UNSUPPORTED), - "cuStreamBatchMemOp": ("hipStreamBatchMemOp", CONV_STREAM, API_DRIVER, HIP_UNSUPPORTED), - "cuArray3DCreate": ("hipArray3DCreate", CONV_MEM, API_DRIVER), - "cuArray3DGetDescriptor": ("hipArray3DGetDescriptor", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuArrayCreate": ("hipArrayCreate", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuArrayDestroy": ("hipArrayDestroy", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuArrayGetDescriptor": ("hipArrayGetDescriptor", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuIpcCloseMemHandle": ("hipIpcCloseMemHandle", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuIpcGetEventHandle": ("hipIpcGetEventHandle", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuIpcGetMemHandle": ("hipIpcGetMemHandle", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuIpcOpenEventHandle": ("hipIpcOpenEventHandle", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuIpcOpenMemHandle": ("hipIpcOpenMemHandle", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemAlloc_v2": ("hipMalloc", CONV_MEM, API_DRIVER), - "cuMemAllocHost": ("hipMemAllocHost", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemAllocManaged": ("hipMemAllocManaged", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemAllocPitch": ("hipMemAllocPitch__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemcpy": ("hipMemcpy__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemcpy2D": ("hipMemcpy2D__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemcpy2DAsync": ("hipMemcpy2DAsync__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemcpy2DUnaligned": ("hipMemcpy2DUnaligned", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemcpy3D": ("hipMemcpy3D__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemcpy3DAsync": ("hipMemcpy3DAsync__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemcpy3DPeer": ("hipMemcpy3DPeer__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemcpy3DPeerAsync": ("hipMemcpy3DPeerAsync__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemcpyAsync": ("hipMemcpyAsync__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemcpyAtoA": ("hipMemcpyAtoA", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemcpyAtoD": ("hipMemcpyAtoD", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemcpyAtoH": ("hipMemcpyAtoH", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemcpyAtoHAsync": ("hipMemcpyAtoHAsync", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemcpyDtoA": ("hipMemcpyDtoA", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemcpyDtoD_v2": ("hipMemcpyDtoD", CONV_MEM, API_DRIVER), - "cuMemcpyDtoDAsync_v2": ("hipMemcpyDtoDAsync", CONV_MEM, API_DRIVER), - "cuMemcpyDtoH_v2": ("hipMemcpyDtoH", CONV_MEM, API_DRIVER), - "cuMemcpyDtoHAsync_v2": ("hipMemcpyDtoHAsync", CONV_MEM, API_DRIVER), - "cuMemcpyHtoA": ("hipMemcpyHtoA", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemcpyHtoAAsync": ("hipMemcpyHtoAAsync", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemcpyHtoD_v2": ("hipMemcpyHtoD", CONV_MEM, API_DRIVER), - "cuMemcpyHtoDAsync_v2": ("hipMemcpyHtoDAsync", CONV_MEM, API_DRIVER), - "cuMemcpyPeerAsync": ("hipMemcpyPeerAsync__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemcpyPeer": ("hipMemcpyPeer__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemFree_v2": ("hipFree", CONV_MEM, API_DRIVER), - "cuMemFreeHost": ("hipHostFree", CONV_MEM, API_DRIVER), - "cuMemGetAddressRange": ("hipMemGetAddressRange", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemGetInfo_v2": ("hipMemGetInfo", CONV_MEM, API_DRIVER), - "cuMemHostAlloc": ("hipHostMalloc", CONV_MEM, API_DRIVER), - "cuMemHostGetDevicePointer": ("hipMemHostGetDevicePointer", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemHostGetFlags": ("hipMemHostGetFlags", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemHostRegister_v2": ("hipHostRegister", CONV_MEM, API_DRIVER), - "cuMemHostUnregister": ("hipHostUnregister", CONV_MEM, API_DRIVER), - "cuMemsetD16_v2": ("hipMemsetD16", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemsetD16Async": ("hipMemsetD16Async", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemsetD2D16_v2": ("hipMemsetD2D16", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemsetD2D16Async": ("hipMemsetD2D16Async", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemsetD2D32_v2": ("hipMemsetD2D32", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemsetD2D32Async": ("hipMemsetD2D32Async", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemsetD2D8_v2": ("hipMemsetD2D8", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemsetD2D8Async": ("hipMemsetD2D8Async", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemsetD32_v2": ("hipMemset", CONV_MEM, API_DRIVER), - "cuMemsetD32Async": ("hipMemsetAsync", CONV_MEM, API_DRIVER), - "cuMemsetD8_v2": ("hipMemsetD8", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemsetD8Async": ("hipMemsetD8Async", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMipmappedArrayCreate": ("hipMipmappedArrayCreate", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMipmappedArrayDestroy": ("hipMipmappedArrayDestroy", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMipmappedArrayGetLevel": ("hipMipmappedArrayGetLevel", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemPrefetchAsync": ("hipMemPrefetchAsync__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemAdvise": ("hipMemAdvise", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemRangeGetAttribute": ("hipMemRangeGetAttribute", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuMemRangeGetAttributes": ("hipMemRangeGetAttributes", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuPointerGetAttribute": ("hipPointerGetAttribute", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuPointerGetAttributes": ("hipPointerGetAttributes", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "cuPointerSetAttribute": ("hipPointerSetAttribute", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED), - "CU_TR_FILTER_MODE_POINT": ("hipFilterModePoint", CONV_TEX, API_DRIVER), - "CU_TR_FILTER_MODE_LINEAR": ("hipFilterModeLinear", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "cuTexRefGetAddress": ("hipTexRefGetAddress", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "cuTexRefGetAddressMode": ("hipTexRefGetAddressMode", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "cuTexRefGetArray": ("hipTexRefGetArray", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "cuTexRefGetBorderColor": ("hipTexRefGetBorderColor", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "cuTexRefGetFilterMode": ("hipTexRefGetFilterMode", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "cuTexRefGetFlags": ("hipTexRefGetFlags", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "cuTexRefGetFormat": ("hipTexRefGetFormat", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "cuTexRefGetMaxAnisotropy": ("hipTexRefGetMaxAnisotropy", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "cuTexRefGetMipmapFilterMode": ("hipTexRefGetMipmapFilterMode", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "cuTexRefGetMipmapLevelBias": ("hipTexRefGetMipmapLevelBias", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "cuTexRefGetMipmapLevelClamp": ("hipTexRefGetMipmapLevelClamp", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "cuTexRefGetMipmappedArray": ("hipTexRefGetMipmappedArray", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "cuTexRefSetAddress": ("hipTexRefSetAddress", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "cuTexRefSetAddress2D": ("hipTexRefSetAddress2D", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "cuTexRefSetAddressMode": ("hipTexRefSetAddressMode", CONV_TEX, API_DRIVER), - "cuTexRefSetArray": ("hipTexRefSetArray", CONV_TEX, API_DRIVER), - "cuTexRefSetBorderColor": ("hipTexRefSetBorderColor", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "cuTexRefSetFilterMode": ("hipTexRefSetFilterMode", CONV_TEX, API_DRIVER), - "cuTexRefSetFlags": ("hipTexRefSetFlags", CONV_TEX, API_DRIVER), - "cuTexRefSetFormat": ("hipTexRefSetFormat", CONV_TEX, API_DRIVER), - "cuTexRefSetMaxAnisotropy": ("hipTexRefSetMaxAnisotropy", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "cuTexRefSetMipmapFilterMode": ("hipTexRefSetMipmapFilterMode", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "cuTexRefSetMipmapLevelBias": ("hipTexRefSetMipmapLevelBias", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "cuTexRefSetMipmapLevelClamp": ("hipTexRefSetMipmapLevelClamp", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "cuTexRefSetMipmappedArray": ("hipTexRefSetMipmappedArray", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "cuTexRefCreate": ("hipTexRefCreate", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "cuTexRefDestroy": ("hipTexRefDestroy", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "cuSurfRefGetArray": ("hipSurfRefGetArray", CONV_SURFACE, API_DRIVER, HIP_UNSUPPORTED), - "cuSurfRefSetArray": ("hipSurfRefSetArray", CONV_SURFACE, API_DRIVER, HIP_UNSUPPORTED), - "cuTexObjectCreate": ("hipTexObjectCreate", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "cuTexObjectDestroy": ("hipTexObjectDestroy", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "cuTexObjectGetResourceDesc": ("hipTexObjectGetResourceDesc", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "cuTexObjectGetResourceViewDesc": ("hipTexObjectGetResourceViewDesc", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "cuTexObjectGetTextureDesc": ("hipTexObjectGetTextureDesc", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "cuSurfObjectCreate": ("hipSurfObjectCreate", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "cuSurfObjectDestroy": ("hipSurfObjectDestroy", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "cuSurfObjectGetResourceDesc": ("hipSurfObjectGetResourceDesc", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED), - "cuGraphicsMapResources": ("hipGraphicsMapResources", CONV_GRAPHICS, API_DRIVER, HIP_UNSUPPORTED), - "cuGraphicsResourceGetMappedMipmappedArray": ("hipGraphicsResourceGetMappedMipmappedArray", CONV_GRAPHICS, API_DRIVER, HIP_UNSUPPORTED), - "cuGraphicsResourceGetMappedPointer": ("hipGraphicsResourceGetMappedPointer", CONV_GRAPHICS, API_DRIVER, HIP_UNSUPPORTED), - "cuGraphicsResourceSetMapFlags": ("hipGraphicsResourceSetMapFlags", CONV_GRAPHICS, API_DRIVER, HIP_UNSUPPORTED), - "cuGraphicsSubResourceGetMappedArray": ("hipGraphicsSubResourceGetMappedArray", CONV_GRAPHICS, API_DRIVER, HIP_UNSUPPORTED), - "cuGraphicsUnmapResources": ("hipGraphicsUnmapResources", CONV_GRAPHICS, API_DRIVER, HIP_UNSUPPORTED), - "cuGraphicsUnregisterResource": ("hipGraphicsUnregisterResource", CONV_GRAPHICS, API_DRIVER, HIP_UNSUPPORTED), - "cuProfilerInitialize": ("hipProfilerInitialize", CONV_OTHER, API_DRIVER, HIP_UNSUPPORTED), - "cuProfilerStart": ("hipProfilerStart", CONV_OTHER, API_DRIVER), - "cuProfilerStop": ("hipProfilerStop", CONV_OTHER, API_DRIVER), - "CU_GL_DEVICE_LIST_ALL": ("HIP_GL_DEVICE_LIST_ALL", CONV_GL, API_DRIVER, HIP_UNSUPPORTED), - "CU_GL_DEVICE_LIST_CURRENT_FRAME": ("HIP_GL_DEVICE_LIST_CURRENT_FRAME", CONV_GL, API_DRIVER, HIP_UNSUPPORTED), - "CU_GL_DEVICE_LIST_NEXT_FRAME": ("HIP_GL_DEVICE_LIST_NEXT_FRAME", CONV_GL, API_DRIVER, HIP_UNSUPPORTED), - "cuGLGetDevices": ("hipGLGetDevices", CONV_GL, API_DRIVER, HIP_UNSUPPORTED), - "cuGraphicsGLRegisterBuffer": ("hipGraphicsGLRegisterBuffer", CONV_GL, API_DRIVER, HIP_UNSUPPORTED), - "cuGraphicsGLRegisterImage": ("hipGraphicsGLRegisterImage", CONV_GL, API_DRIVER, HIP_UNSUPPORTED), - "cuWGLGetDevice": ("hipWGLGetDevice", CONV_GL, API_DRIVER, HIP_UNSUPPORTED), - "CU_GL_MAP_RESOURCE_FLAGS_NONE": ("HIP_GL_MAP_RESOURCE_FLAGS_NONE", CONV_GL, API_DRIVER, HIP_UNSUPPORTED), - "CU_GL_MAP_RESOURCE_FLAGS_READ_ONLY": ("HIP_GL_MAP_RESOURCE_FLAGS_READ_ONLY", CONV_GL, API_DRIVER, HIP_UNSUPPORTED), - "CU_GL_MAP_RESOURCE_FLAGS_WRITE_DISCARD": ("HIP_GL_MAP_RESOURCE_FLAGS_WRITE_DISCARD", CONV_GL, API_DRIVER, HIP_UNSUPPORTED), - "cuGLCtxCreate": ("hipGLCtxCreate", CONV_GL, API_DRIVER, HIP_UNSUPPORTED), - "cuGLInit": ("hipGLInit", CONV_GL, API_DRIVER, HIP_UNSUPPORTED), - "cuGLMapBufferObject": ("hipGLMapBufferObject", CONV_GL, API_DRIVER, HIP_UNSUPPORTED), - "cuGLMapBufferObjectAsync": ("hipGLMapBufferObjectAsync", CONV_GL, API_DRIVER, HIP_UNSUPPORTED), - "cuGLRegisterBufferObject": ("hipGLRegisterBufferObject", CONV_GL, API_DRIVER, HIP_UNSUPPORTED), - "cuGLSetBufferObjectMapFlags": ("hipGLSetBufferObjectMapFlags", CONV_GL, API_DRIVER, HIP_UNSUPPORTED), - "cuGLUnmapBufferObject": ("hipGLUnmapBufferObject", CONV_GL, API_DRIVER, HIP_UNSUPPORTED), - "cuGLUnmapBufferObjectAsync": ("hipGLUnmapBufferObjectAsync", CONV_GL, API_DRIVER, HIP_UNSUPPORTED), - "cuGLUnregisterBufferObject": ("hipGLUnregisterBufferObject", CONV_GL, API_DRIVER, HIP_UNSUPPORTED), - "CU_D3D9_DEVICE_LIST_ALL": ("HIP_D3D9_DEVICE_LIST_ALL", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED), - "CU_D3D9_DEVICE_LIST_CURRENT_FRAME": ("HIP_D3D9_DEVICE_LIST_CURRENT_FRAME", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED), - "CU_D3D9_DEVICE_LIST_NEXT_FRAME": ("HIP_D3D9_DEVICE_LIST_NEXT_FRAME", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D9CtxCreate": ("hipD3D9CtxCreate", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D9CtxCreateOnDevice": ("hipD3D9CtxCreateOnDevice", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D9GetDevice": ("hipD3D9GetDevice", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D9GetDevices": ("hipD3D9GetDevices", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D9GetDirect3DDevice": ("hipD3D9GetDirect3DDevice", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED), - "cuGraphicsD3D9RegisterResource": ("hipGraphicsD3D9RegisterResource", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED), - "CU_D3D9_MAPRESOURCE_FLAGS_NONE": ("HIP_D3D9_MAPRESOURCE_FLAGS_NONE", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED), - "CU_D3D9_MAPRESOURCE_FLAGS_READONLY": ("HIP_D3D9_MAPRESOURCE_FLAGS_READONLY", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED), - "CU_D3D9_MAPRESOURCE_FLAGS_WRITEDISCARD": ("HIP_D3D9_MAPRESOURCE_FLAGS_WRITEDISCARD", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED), - "CU_D3D9_REGISTER_FLAGS_NONE": ("HIP_D3D9_REGISTER_FLAGS_NONE", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED), - "CU_D3D9_REGISTER_FLAGS_ARRAY": ("HIP_D3D9_REGISTER_FLAGS_ARRAY", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D9MapResources": ("hipD3D9MapResources", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D9RegisterResource": ("hipD3D9RegisterResource", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D9ResourceGetMappedArray": ("hipD3D9ResourceGetMappedArray", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D9ResourceGetMappedPitch": ("hipD3D9ResourceGetMappedPitch", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D9ResourceGetMappedPointer": ("hipD3D9ResourceGetMappedPointer", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D9ResourceGetMappedSize": ("hipD3D9ResourceGetMappedSize", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D9ResourceGetSurfaceDimensions": ("hipD3D9ResourceGetSurfaceDimensions", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D9ResourceSetMapFlags": ("hipD3D9ResourceSetMapFlags", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D9UnmapResources": ("hipD3D9UnmapResources", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D9UnregisterResource": ("hipD3D9UnregisterResource", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED), - "CU_D3D10_DEVICE_LIST_ALL": ("HIP_D3D10_DEVICE_LIST_ALL", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED), - "CU_D3D10_DEVICE_LIST_CURRENT_FRAME": ("HIP_D3D10_DEVICE_LIST_CURRENT_FRAME", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED), - "CU_D3D10_DEVICE_LIST_NEXT_FRAME": ("HIP_D3D10_DEVICE_LIST_NEXT_FRAME", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D10GetDevice": ("hipD3D10GetDevice", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D10GetDevices": ("hipD3D10GetDevices", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED), - "cuGraphicsD3D10RegisterResource": ("hipGraphicsD3D10RegisterResource", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED), - "CU_D3D10_MAPRESOURCE_FLAGS_NONE": ("HIP_D3D10_MAPRESOURCE_FLAGS_NONE", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED), - "CU_D3D10_MAPRESOURCE_FLAGS_READONLY": ("HIP_D3D10_MAPRESOURCE_FLAGS_READONLY", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED), - "CU_D3D10_MAPRESOURCE_FLAGS_WRITEDISCARD": ("HIP_D3D10_MAPRESOURCE_FLAGS_WRITEDISCARD", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED), - "CU_D3D10_REGISTER_FLAGS_NONE": ("HIP_D3D10_REGISTER_FLAGS_NONE", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED), - "CU_D3D10_REGISTER_FLAGS_ARRAY": ("HIP_D3D10_REGISTER_FLAGS_ARRAY", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D10CtxCreate": ("hipD3D10CtxCreate", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D10CtxCreateOnDevice": ("hipD3D10CtxCreateOnDevice", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D10GetDirect3DDevice": ("hipD3D10GetDirect3DDevice", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D10MapResources": ("hipD3D10MapResources", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D10RegisterResource": ("hipD3D10RegisterResource", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D10ResourceGetMappedArray": ("hipD3D10ResourceGetMappedArray", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D10ResourceGetMappedPitch": ("hipD3D10ResourceGetMappedPitch", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D10ResourceGetMappedPointer": ("hipD3D10ResourceGetMappedPointer", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D10ResourceGetMappedSize": ("hipD3D10ResourceGetMappedSize", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D10ResourceGetSurfaceDimensions": ("hipD3D10ResourceGetSurfaceDimensions", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED), - "cuD310ResourceSetMapFlags": ("hipD3D10ResourceSetMapFlags", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D10UnmapResources": ("hipD3D10UnmapResources", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D10UnregisterResource": ("hipD3D10UnregisterResource", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED), - "CU_D3D11_DEVICE_LIST_ALL": ("HIP_D3D11_DEVICE_LIST_ALL", CONV_D3D11, API_DRIVER, HIP_UNSUPPORTED), - "CU_D3D11_DEVICE_LIST_CURRENT_FRAME": ("HIP_D3D11_DEVICE_LIST_CURRENT_FRAME", CONV_D3D11, API_DRIVER, HIP_UNSUPPORTED), - "CU_D3D11_DEVICE_LIST_NEXT_FRAME": ("HIP_D3D11_DEVICE_LIST_NEXT_FRAME", CONV_D3D11, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D11GetDevice": ("hipD3D11GetDevice", CONV_D3D11, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D11GetDevices": ("hipD3D11GetDevices", CONV_D3D11, API_DRIVER, HIP_UNSUPPORTED), - "cuGraphicsD3D11RegisterResource": ("hipGraphicsD3D11RegisterResource", CONV_D3D11, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D11CtxCreate": ("hipD3D11CtxCreate", CONV_D3D11, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D11CtxCreateOnDevice": ("hipD3D11CtxCreateOnDevice", CONV_D3D11, API_DRIVER, HIP_UNSUPPORTED), - "cuD3D11GetDirect3DDevice": ("hipD3D11GetDirect3DDevice", CONV_D3D11, API_DRIVER, HIP_UNSUPPORTED), - "cuGraphicsVDPAURegisterOutputSurface": ("hipGraphicsVDPAURegisterOutputSurface", CONV_VDPAU, API_DRIVER, HIP_UNSUPPORTED), - "cuGraphicsVDPAURegisterVideoSurface": ("hipGraphicsVDPAURegisterVideoSurface", CONV_VDPAU, API_DRIVER, HIP_UNSUPPORTED), - "cuVDPAUGetDevice": ("hipVDPAUGetDevice", CONV_VDPAU, API_DRIVER, HIP_UNSUPPORTED), - "cuVDPAUCtxCreate": ("hipVDPAUCtxCreate", CONV_VDPAU, API_DRIVER, HIP_UNSUPPORTED), - "cuEGLStreamConsumerAcquireFrame": ("hipEGLStreamConsumerAcquireFrame", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED), - "cuEGLStreamConsumerConnect": ("hipEGLStreamConsumerConnect", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED), - "cuEGLStreamConsumerConnectWithFlags": ("hipEGLStreamConsumerConnectWithFlags", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED), - "cuEGLStreamConsumerDisconnect": ("hipEGLStreamConsumerDisconnect", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED), - "cuEGLStreamConsumerReleaseFrame": ("hipEGLStreamConsumerReleaseFrame", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED), - "cuEGLStreamProducerConnect": ("hipEGLStreamProducerConnect", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED), - "cuEGLStreamProducerDisconnect": ("hipEGLStreamProducerDisconnect", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED), - "cuEGLStreamProducerPresentFrame": ("hipEGLStreamProducerPresentFrame", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED), - "cuEGLStreamProducerReturnFrame": ("hipEGLStreamProducerReturnFrame", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED), - "cuGraphicsEGLRegisterImage": ("hipGraphicsEGLRegisterImage", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED), - "cuGraphicsResourceGetMappedEglFrame": ("hipGraphicsResourceGetMappedEglFrame", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED), - "cudaDataType_t": ("hipDataType_t", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDataType": ("hipDataType_t", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_R_16F": ("hipR16F", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_C_16F": ("hipC16F", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_R_32F": ("hipR32F", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_C_32F": ("hipC32F", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_R_64F": ("hipR64F", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_C_64F": ("hipC64F", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_R_8I": ("hipR8I", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_C_8I": ("hipC8I", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_R_8U": ("hipR8U", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_C_8U": ("hipC8U", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_R_32I": ("hipR32I", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_C_32I": ("hipC32I", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_R_32U": ("hipR32U", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "CUDA_C_32U": ("hipC32U", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "MAJOR_VERSION": ("hipLibraryMajorVersion", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "MINOR_VERSION": ("hipLibraryMinorVersion", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "PATCH_LEVEL": ("hipLibraryPatchVersion", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMemAttachGlobal": ("hipMemAttachGlobal", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMemAttachHost": ("hipMemAttachHost", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMemAttachSingle": ("hipMemAttachSingle", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaOccupancyDefault": ("hipOccupancyDefault", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaOccupancyDisableCachingOverride": ("hipOccupancyDisableCachingOverride", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGetLastError": ("hipGetLastError", CONV_ERROR, API_RUNTIME), - "cudaPeekAtLastError": ("hipPeekAtLastError", CONV_ERROR, API_RUNTIME), - "cudaGetErrorName": ("hipGetErrorName", CONV_ERROR, API_RUNTIME), - "cudaGetErrorString": ("hipGetErrorString", CONV_ERROR, API_RUNTIME), - "cudaMemcpy3DParms": ("hipMemcpy3DParms", CONV_MEM, API_RUNTIME), - "cudaMemcpy3DPeerParms": ("hipMemcpy3DPeerParms", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMemcpy": ("hipMemcpy", CONV_MEM, API_RUNTIME), - "cudaMemcpyToArray": ("hipMemcpyToArray", CONV_MEM, API_RUNTIME), - "cudaMemcpyToSymbol": ("hipMemcpyToSymbol", CONV_MEM, API_RUNTIME), - "cudaMemcpyToSymbolAsync": ("hipMemcpyToSymbolAsync", CONV_MEM, API_RUNTIME), - "cudaMemcpyAsync": ("hipMemcpyAsync", CONV_MEM, API_RUNTIME), - "cudaMemcpy2D": ("hipMemcpy2D", CONV_MEM, API_RUNTIME), - "cudaMemcpy2DAsync": ("hipMemcpy2DAsync", CONV_MEM, API_RUNTIME), - "cudaMemcpy2DToArray": ("hipMemcpy2DToArray", CONV_MEM, API_RUNTIME), - "cudaMemcpy2DArrayToArray": ("hipMemcpy2DArrayToArray", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMemcpy2DFromArray": ("hipMemcpy2DFromArray", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMemcpy2DFromArrayAsync": ("hipMemcpy2DFromArrayAsync", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMemcpy2DToArrayAsync": ("hipMemcpy2DToArrayAsync", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMemcpy3D": ("hipMemcpy3D", CONV_MEM, API_RUNTIME), - "cudaMemcpy3DAsync": ("hipMemcpy3DAsync", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMemcpy3DPeer": ("hipMemcpy3DPeer", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMemcpy3DPeerAsync": ("hipMemcpy3DPeerAsync", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMemcpyArrayToArray": ("hipMemcpyArrayToArray", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMemcpyFromArrayAsync": ("hipMemcpyFromArrayAsync", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMemcpyFromSymbol": ("hipMemcpyFromSymbol", CONV_MEM, API_RUNTIME), - "cudaMemcpyFromSymbolAsync": ("hipMemcpyFromSymbolAsync", CONV_MEM, API_RUNTIME), - "cudaMemAdvise": ("hipMemAdvise", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMemRangeGetAttribute": ("hipMemRangeGetAttribute", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMemRangeGetAttributes": ("hipMemRangeGetAttributes", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMemAdviseSetReadMostly": ("hipMemAdviseSetReadMostly", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMemAdviseUnsetReadMostly": ("hipMemAdviseUnsetReadMostly", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMemAdviseSetPreferredLocation": ("hipMemAdviseSetPreferredLocation", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMemAdviseUnsetPreferredLocation": ("hipMemAdviseUnsetPreferredLocation", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMemAdviseSetAccessedBy": ("hipMemAdviseSetAccessedBy", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMemAdviseUnsetAccessedBy": ("hipMemAdviseUnsetAccessedBy", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMemRangeAttributeReadMostly": ("hipMemRangeAttributeReadMostly", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMemRangeAttributePreferredLocation": ("hipMemRangeAttributePreferredLocation", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMemRangeAttributeAccessedBy": ("hipMemRangeAttributeAccessedBy", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMemRangeAttributeLastPrefetchLocation": ("hipMemRangeAttributeLastPrefetchLocation", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMemcpyHostToHost": ("hipMemcpyHostToHost", CONV_MEM, API_RUNTIME), - "cudaMemcpyHostToDevice": ("hipMemcpyHostToDevice", CONV_MEM, API_RUNTIME), - "cudaMemcpyDeviceToHost": ("hipMemcpyDeviceToHost", CONV_MEM, API_RUNTIME), - "cudaMemcpyDeviceToDevice": ("hipMemcpyDeviceToDevice", CONV_MEM, API_RUNTIME), - "cudaMemcpyDefault": ("hipMemcpyDefault", CONV_MEM, API_RUNTIME), - "cudaMemset": ("hipMemset", CONV_MEM, API_RUNTIME), - "cudaMemsetAsync": ("hipMemsetAsync", CONV_MEM, API_RUNTIME), - "cudaMemset2D": ("hipMemset2D", CONV_MEM, API_RUNTIME), - "cudaMemset2DAsync": ("hipMemset2DAsync", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMemset3D": ("hipMemset3D", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMemset3DAsync": ("hipMemset3DAsync", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMemGetInfo": ("hipMemGetInfo", CONV_MEM, API_RUNTIME), - "cudaArrayGetInfo": ("hipArrayGetInfo", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED), - "cudaFreeMipmappedArray": ("hipFreeMipmappedArray", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGetMipmappedArrayLevel": ("hipGetMipmappedArrayLevel", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGetSymbolAddress": ("hipGetSymbolAddress", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGetSymbolSize": ("hipGetSymbolSize", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMemPrefetchAsync": ("hipMemPrefetchAsync", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMalloc": ("hipMalloc", CONV_MEM, API_RUNTIME), - "cudaMallocHost": ("hipHostMalloc", CONV_MEM, API_RUNTIME), - "cudaMallocArray": ("hipMallocArray", CONV_MEM, API_RUNTIME), - "cudaMalloc3D": ("hipMalloc3D", CONV_MEM, API_RUNTIME), - "cudaMalloc3DArray": ("hipMalloc3DArray", CONV_MEM, API_RUNTIME), - "cudaMallocManaged": ("hipMallocManaged", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMallocMipmappedArray": ("hipMallocMipmappedArray", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED), - "cudaMallocPitch": ("hipMallocPitch", CONV_MEM, API_RUNTIME), - "cudaFree": ("hipFree", CONV_MEM, API_RUNTIME), - "cudaFreeHost": ("hipHostFree", CONV_MEM, API_RUNTIME), - "cudaFreeArray": ("hipFreeArray", CONV_MEM, API_RUNTIME), - "cudaHostRegister": ("hipHostRegister", CONV_MEM, API_RUNTIME), - "cudaHostUnregister": ("hipHostUnregister", CONV_MEM, API_RUNTIME), - "cudaHostAlloc": ("hipHostMalloc", CONV_MEM, API_RUNTIME), - "cudaMemoryTypeHost": ("hipMemoryTypeHost", CONV_MEM, API_RUNTIME), - "cudaMemoryTypeDevice": ("hipMemoryTypeDevice", CONV_MEM, API_RUNTIME), - "make_cudaExtent": ("make_hipExtent", CONV_MEM, API_RUNTIME), - "make_cudaPitchedPtr": ("make_hipPitchedPtr", CONV_MEM, API_RUNTIME), - "make_cudaPos": ("make_hipPos", CONV_MEM, API_RUNTIME), - "cudaHostAllocDefault": ("hipHostMallocDefault", CONV_MEM, API_RUNTIME), - "cudaHostAllocPortable": ("hipHostMallocPortable", CONV_MEM, API_RUNTIME), - "cudaHostAllocMapped": ("hipHostMallocMapped", CONV_MEM, API_RUNTIME), - "cudaHostAllocWriteCombined": ("hipHostMallocWriteCombined", CONV_MEM, API_RUNTIME), - "cudaHostGetFlags": ("hipHostGetFlags", CONV_MEM, API_RUNTIME), - "cudaHostRegisterDefault": ("hipHostRegisterDefault", CONV_MEM, API_RUNTIME), - "cudaHostRegisterPortable": ("hipHostRegisterPortable", CONV_MEM, API_RUNTIME), - "cudaHostRegisterMapped": ("hipHostRegisterMapped", CONV_MEM, API_RUNTIME), - "cudaHostRegisterIoMemory": ("hipHostRegisterIoMemory", CONV_MEM, API_RUNTIME), - # "warpSize": ("hipWarpSize", CONV_SPECIAL_FUNC, API_RUNTIME), (HIP actually uses warpSize...) - "cudaEventCreate": ("hipEventCreate", CONV_EVENT, API_RUNTIME), - "cudaEventCreateWithFlags": ("hipEventCreateWithFlags", CONV_EVENT, API_RUNTIME), - "cudaEventDestroy": ("hipEventDestroy", CONV_EVENT, API_RUNTIME), - "cudaEventRecord": ("hipEventRecord", CONV_EVENT, API_RUNTIME), - "cudaEventElapsedTime": ("hipEventElapsedTime", CONV_EVENT, API_RUNTIME), - "cudaEventSynchronize": ("hipEventSynchronize", CONV_EVENT, API_RUNTIME), - "cudaEventQuery": ("hipEventQuery", CONV_EVENT, API_RUNTIME), - "cudaEventDefault": ("hipEventDefault", CONV_EVENT, API_RUNTIME), - "cudaEventBlockingSync": ("hipEventBlockingSync", CONV_EVENT, API_RUNTIME), - "cudaEventDisableTiming": ("hipEventDisableTiming", CONV_EVENT, API_RUNTIME), - "cudaEventInterprocess": ("hipEventInterprocess", CONV_EVENT, API_RUNTIME), - "cudaStreamCreate": ("hipStreamCreate", CONV_STREAM, API_RUNTIME), - "cudaStreamCreateWithFlags": ("hipStreamCreateWithFlags", CONV_STREAM, API_RUNTIME), - "cudaStreamCreateWithPriority": ("hipStreamCreateWithPriority", CONV_STREAM, API_RUNTIME, HIP_UNSUPPORTED), - "cudaStreamDestroy": ("hipStreamDestroy", CONV_STREAM, API_RUNTIME), - "cudaStreamWaitEvent": ("hipStreamWaitEvent", CONV_STREAM, API_RUNTIME), - "cudaStreamSynchronize": ("hipStreamSynchronize", CONV_STREAM, API_RUNTIME), - "cudaStreamGetFlags": ("hipStreamGetFlags", CONV_STREAM, API_RUNTIME), - "cudaStreamQuery": ("hipStreamQuery", CONV_STREAM, API_RUNTIME), - "cudaStreamAddCallback": ("hipStreamAddCallback", CONV_STREAM, API_RUNTIME), - "cudaStreamAttachMemAsync": ("hipStreamAttachMemAsync", CONV_STREAM, API_RUNTIME, HIP_UNSUPPORTED), - "cudaStreamGetPriority": ("hipStreamGetPriority", CONV_STREAM, API_RUNTIME, HIP_UNSUPPORTED), - "cudaStreamDefault": ("hipStreamDefault", CONV_TYPE, API_RUNTIME), - "cudaStreamNonBlocking": ("hipStreamNonBlocking", CONV_TYPE, API_RUNTIME), - "cudaDeviceSynchronize": ("hipDeviceSynchronize", CONV_DEVICE, API_RUNTIME), - "cudaDeviceReset": ("hipDeviceReset", CONV_DEVICE, API_RUNTIME), - "cudaSetDevice": ("hipSetDevice", CONV_DEVICE, API_RUNTIME), - "cudaGetDevice": ("hipGetDevice", CONV_DEVICE, API_RUNTIME), - "cudaGetDeviceCount": ("hipGetDeviceCount", CONV_DEVICE, API_RUNTIME), - "cudaChooseDevice": ("hipChooseDevice", CONV_DEVICE, API_RUNTIME), - "cudaThreadExit": ("hipDeviceReset", CONV_THREAD, API_RUNTIME), - "cudaThreadGetCacheConfig": ("hipDeviceGetCacheConfig", CONV_THREAD, API_RUNTIME), - "cudaThreadGetLimit": ("hipThreadGetLimit", CONV_THREAD, API_RUNTIME, HIP_UNSUPPORTED), - "cudaThreadSetCacheConfig": ("hipDeviceSetCacheConfig", CONV_THREAD, API_RUNTIME), - "cudaThreadSetLimit": ("hipThreadSetLimit", CONV_THREAD, API_RUNTIME, HIP_UNSUPPORTED), - "cudaThreadSynchronize": ("hipDeviceSynchronize", CONV_THREAD, API_RUNTIME), - "cudaDeviceGetAttribute": ("hipDeviceGetAttribute", CONV_DEVICE, API_RUNTIME), - "cudaDevAttrMaxThreadsPerBlock": ("hipDeviceAttributeMaxThreadsPerBlock", CONV_TYPE, API_RUNTIME), - "cudaDevAttrMaxBlockDimX": ("hipDeviceAttributeMaxBlockDimX", CONV_TYPE, API_RUNTIME), - "cudaDevAttrMaxBlockDimY": ("hipDeviceAttributeMaxBlockDimY", CONV_TYPE, API_RUNTIME), - "cudaDevAttrMaxBlockDimZ": ("hipDeviceAttributeMaxBlockDimZ", CONV_TYPE, API_RUNTIME), - "cudaDevAttrMaxGridDimX": ("hipDeviceAttributeMaxGridDimX", CONV_TYPE, API_RUNTIME), - "cudaDevAttrMaxGridDimY": ("hipDeviceAttributeMaxGridDimY", CONV_TYPE, API_RUNTIME), - "cudaDevAttrMaxGridDimZ": ("hipDeviceAttributeMaxGridDimZ", CONV_TYPE, API_RUNTIME), - "cudaDevAttrMaxSharedMemoryPerBlock": ("hipDeviceAttributeMaxSharedMemoryPerBlock", CONV_TYPE, API_RUNTIME), - "cudaDevAttrTotalConstantMemory": ("hipDeviceAttributeTotalConstantMemory", CONV_TYPE, API_RUNTIME), - "cudaDevAttrWarpSize": ("hipDeviceAttributeWarpSize", CONV_TYPE, API_RUNTIME), - "cudaDevAttrMaxPitch": ("hipDeviceAttributeMaxPitch", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxRegistersPerBlock": ("hipDeviceAttributeMaxRegistersPerBlock", CONV_TYPE, API_RUNTIME), - "cudaDevAttrClockRate": ("hipDeviceAttributeClockRate", CONV_TYPE, API_RUNTIME), - "cudaDevAttrTextureAlignment": ("hipDeviceAttributeTextureAlignment", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrGpuOverlap": ("hipDeviceAttributeGpuOverlap", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMultiProcessorCount": ("hipDeviceAttributeMultiprocessorCount", CONV_TYPE, API_RUNTIME), - "cudaDevAttrKernelExecTimeout": ("hipDeviceAttributeKernelExecTimeout", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrIntegrated": ("hipDeviceAttributeIntegrated", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrCanMapHostMemory": ("hipDeviceAttributeCanMapHostMemory", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrComputeMode": ("hipDeviceAttributeComputeMode", CONV_TYPE, API_RUNTIME), - "cudaDevAttrMaxTexture1DWidth": ("hipDeviceAttributeMaxTexture1DWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxTexture2DWidth": ("hipDeviceAttributeMaxTexture2DWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxTexture2DHeight": ("hipDeviceAttributeMaxTexture2DHeight", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxTexture3DWidth": ("hipDeviceAttributeMaxTexture3DWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxTexture3DHeight": ("hipDeviceAttributeMaxTexture3DHeight", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxTexture3DDepth": ("hipDeviceAttributeMaxTexture3DDepth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxTexture2DLayeredWidth": ("hipDeviceAttributeMaxTexture2DLayeredWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxTexture2DLayeredHeight": ("hipDeviceAttributeMaxTexture2DLayeredHeight", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxTexture2DLayeredLayers": ("hipDeviceAttributeMaxTexture2DLayeredLayers", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrSurfaceAlignment": ("hipDeviceAttributeSurfaceAlignment", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrConcurrentKernels": ("hipDeviceAttributeConcurrentKernels", CONV_TYPE, API_RUNTIME), - "cudaDevAttrEccEnabled": ("hipDeviceAttributeEccEnabled", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrPciBusId": ("hipDeviceAttributePciBusId", CONV_TYPE, API_RUNTIME), - "cudaDevAttrPciDeviceId": ("hipDeviceAttributePciDeviceId", CONV_TYPE, API_RUNTIME), - "cudaDevAttrTccDriver": ("hipDeviceAttributeTccDriver", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMemoryClockRate": ("hipDeviceAttributeMemoryClockRate", CONV_TYPE, API_RUNTIME), - "cudaDevAttrGlobalMemoryBusWidth": ("hipDeviceAttributeMemoryBusWidth", CONV_TYPE, API_RUNTIME), - "cudaDevAttrL2CacheSize": ("hipDeviceAttributeL2CacheSize", CONV_TYPE, API_RUNTIME), - "cudaDevAttrMaxThreadsPerMultiProcessor": ("hipDeviceAttributeMaxThreadsPerMultiProcessor", CONV_TYPE, API_RUNTIME), - "cudaDevAttrAsyncEngineCount": ("hipDeviceAttributeAsyncEngineCount", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrUnifiedAddressing": ("hipDeviceAttributeUnifiedAddressing", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxTexture1DLayeredWidth": ("hipDeviceAttributeMaxTexture1DLayeredWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxTexture1DLayeredLayers": ("hipDeviceAttributeMaxTexture1DLayeredLayers", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxTexture2DGatherWidth": ("hipDeviceAttributeMaxTexture2DGatherWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxTexture2DGatherHeight": ("hipDeviceAttributeMaxTexture2DGatherHeight", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxTexture3DWidthAlt": ("hipDeviceAttributeMaxTexture3DWidthAlternate", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxTexture3DHeightAlt": ("hipDeviceAttributeMaxTexture3DHeightAlternate", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxTexture3DDepthAlt": ("hipDeviceAttributeMaxTexture3DDepthAlternate", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrPciDomainId": ("hipDeviceAttributePciDomainId", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrTexturePitchAlignment": ("hipDeviceAttributeTexturePitchAlignment", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxTextureCubemapWidth": ("hipDeviceAttributeMaxTextureCubemapWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxTextureCubemapLayeredWidth": ("hipDeviceAttributeMaxTextureCubemapLayeredWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxTextureCubemapLayeredLayers": ("hipDeviceAttributeMaxTextureCubemapLayeredLayers", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxSurface1DWidth": ("hipDeviceAttributeMaxSurface1DWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxSurface2DWidth": ("hipDeviceAttributeMaxSurface2DWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxSurface2DHeight": ("hipDeviceAttributeMaxSurface2DHeight", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxSurface3DWidth": ("hipDeviceAttributeMaxSurface3DWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxSurface3DHeight": ("hipDeviceAttributeMaxSurface3DHeight", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxSurface3DDepth": ("hipDeviceAttributeMaxSurface3DDepth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxSurface1DLayeredWidth": ("hipDeviceAttributeMaxSurface1DLayeredWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxSurface1DLayeredLayers": ("hipDeviceAttributeMaxSurface1DLayeredLayers", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxSurface2DLayeredWidth": ("hipDeviceAttributeMaxSurface2DLayeredWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxSurface2DLayeredHeight": ("hipDeviceAttributeMaxSurface2DLayeredHeight", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxSurface2DLayeredLayers": ("hipDeviceAttributeMaxSurface2DLayeredLayers", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxSurfaceCubemapWidth": ("hipDeviceAttributeMaxSurfaceCubemapWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxSurfaceCubemapLayeredWidth": ("hipDeviceAttributeMaxSurfaceCubemapLayeredWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxSurfaceCubemapLayeredLayers": ("hipDeviceAttributeMaxSurfaceCubemapLayeredLayers", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxTexture1DLinearWidth": ("hipDeviceAttributeMaxTexture1DLinearWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxTexture2DLinearWidth": ("hipDeviceAttributeMaxTexture2DLinearWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxTexture2DLinearHeight": ("hipDeviceAttributeMaxTexture2DLinearHeight", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxTexture2DLinearPitch": ("hipDeviceAttributeMaxTexture2DLinearPitch", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxTexture2DMipmappedWidth": ("hipDeviceAttributeMaxTexture2DMipmappedWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxTexture2DMipmappedHeight": ("hipDeviceAttributeMaxTexture2DMipmappedHeight", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrComputeCapabilityMajor": ("hipDeviceAttributeComputeCapabilityMajor", CONV_TYPE, API_RUNTIME), - "cudaDevAttrComputeCapabilityMinor": ("hipDeviceAttributeComputeCapabilityMinor", CONV_TYPE, API_RUNTIME), - "cudaDevAttrMaxTexture1DMipmappedWidth": ("hipDeviceAttributeMaxTexture1DMipmappedWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrStreamPrioritiesSupported": ("hipDeviceAttributeStreamPrioritiesSupported", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrGlobalL1CacheSupported": ("hipDeviceAttributeGlobalL1CacheSupported", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrLocalL1CacheSupported": ("hipDeviceAttributeLocalL1CacheSupported", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrMaxSharedMemoryPerMultiprocessor": ("hipDeviceAttributeMaxSharedMemoryPerMultiprocessor", CONV_TYPE, API_RUNTIME), - "cudaDevAttrMaxRegistersPerMultiprocessor": ("hipDeviceAttributeMaxRegistersPerMultiprocessor", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrManagedMemory": ("hipDeviceAttributeManagedMemory", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrIsMultiGpuBoard": ("hipDeviceAttributeIsMultiGpuBoard", CONV_TYPE, API_RUNTIME), - "cudaDevAttrMultiGpuBoardGroupID": ("hipDeviceAttributeMultiGpuBoardGroupID", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrHostNativeAtomicSupported": ("hipDeviceAttributeHostNativeAtomicSupported", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrSingleToDoublePrecisionPerfRatio": ("hipDeviceAttributeSingleToDoublePrecisionPerfRatio", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrPageableMemoryAccess": ("hipDeviceAttributePageableMemoryAccess", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrConcurrentManagedAccess": ("hipDeviceAttributeConcurrentManagedAccess", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrComputePreemptionSupported": ("hipDeviceAttributeComputePreemptionSupported", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevAttrCanUseHostPointerForRegisteredMem": ("hipDeviceAttributeCanUseHostPointerForRegisteredMem", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaPointerGetAttributes": ("hipPointerGetAttributes", CONV_MEM, API_RUNTIME), - "cudaHostGetDevicePointer": ("hipHostGetDevicePointer", CONV_MEM, API_RUNTIME), - "cudaGetDeviceProperties": ("hipGetDeviceProperties", CONV_DEVICE, API_RUNTIME), - "cudaDeviceGetPCIBusId": ("hipDeviceGetPCIBusId", CONV_DEVICE, API_RUNTIME), - "cudaDeviceGetByPCIBusId": ("hipDeviceGetByPCIBusId", CONV_DEVICE, API_RUNTIME), - "cudaDeviceGetStreamPriorityRange": ("hipDeviceGetStreamPriorityRange", CONV_DEVICE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaSetValidDevices": ("hipSetValidDevices", CONV_DEVICE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevP2PAttrPerformanceRank": ("hipDeviceP2PAttributePerformanceRank", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevP2PAttrAccessSupported": ("hipDeviceP2PAttributeAccessSupported", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDevP2PAttrNativeAtomicSupported": ("hipDeviceP2PAttributeNativeAtomicSupported", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDeviceGetP2PAttribute": ("hipDeviceGetP2PAttribute", CONV_DEVICE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaComputeModeDefault": ("hipComputeModeDefault", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaComputeModeExclusive": ("hipComputeModeExclusive", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaComputeModeProhibited": ("hipComputeModeProhibited", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaComputeModeExclusiveProcess": ("hipComputeModeExclusiveProcess", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGetDeviceFlags": ("hipGetDeviceFlags", CONV_DEVICE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaSetDeviceFlags": ("hipSetDeviceFlags", CONV_DEVICE, API_RUNTIME), - "cudaDeviceScheduleAuto": ("hipDeviceScheduleAuto", CONV_TYPE, API_RUNTIME), - "cudaDeviceScheduleSpin": ("hipDeviceScheduleSpin", CONV_TYPE, API_RUNTIME), - "cudaDeviceScheduleYield": ("hipDeviceScheduleYield", CONV_TYPE, API_RUNTIME), - "cudaDeviceBlockingSync": ("hipDeviceScheduleBlockingSync", CONV_TYPE, API_RUNTIME), - "cudaDeviceScheduleBlockingSync": ("hipDeviceScheduleBlockingSync", CONV_TYPE, API_RUNTIME), - "cudaDeviceScheduleMask": ("hipDeviceScheduleMask", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDeviceMapHost": ("hipDeviceMapHost", CONV_TYPE, API_RUNTIME), - "cudaDeviceLmemResizeToMax": ("hipDeviceLmemResizeToMax", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDeviceMask": ("hipDeviceMask", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDeviceSetCacheConfig": ("hipDeviceSetCacheConfig", CONV_CACHE, API_RUNTIME), - "cudaDeviceGetCacheConfig": ("hipDeviceGetCacheConfig", CONV_CACHE, API_RUNTIME), - "cudaFuncSetCacheConfig": ("hipFuncSetCacheConfig", CONV_CACHE, API_RUNTIME), - "cudaFuncCachePreferNone": ("hipFuncCachePreferNone", CONV_CACHE, API_RUNTIME), - "cudaFuncCachePreferShared": ("hipFuncCachePreferShared", CONV_CACHE, API_RUNTIME), - "cudaFuncCachePreferL1": ("hipFuncCachePreferL1", CONV_CACHE, API_RUNTIME), - "cudaFuncCachePreferEqual": ("hipFuncCachePreferEqual", CONV_CACHE, API_RUNTIME), - "cudaFuncGetAttributes": ("hipFuncGetAttributes", CONV_EXEC, API_RUNTIME, HIP_UNSUPPORTED), - "cudaFuncSetSharedMemConfig": ("hipFuncSetSharedMemConfig", CONV_EXEC, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGetParameterBuffer": ("hipGetParameterBuffer", CONV_EXEC, API_RUNTIME, HIP_UNSUPPORTED), - "cudaSetDoubleForDevice": ("hipSetDoubleForDevice", CONV_EXEC, API_RUNTIME, HIP_UNSUPPORTED), - "cudaSetDoubleForHost": ("hipSetDoubleForHost", CONV_EXEC, API_RUNTIME, HIP_UNSUPPORTED), - "cudaConfigureCall": ("hipConfigureCall", CONV_EXEC, API_RUNTIME, HIP_UNSUPPORTED), - "cudaLaunch": ("hipLaunch", CONV_EXEC, API_RUNTIME, HIP_UNSUPPORTED), - "cudaSetupArgument": ("hipSetupArgument", CONV_EXEC, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDriverGetVersion": ("hipDriverGetVersion", CONV_VERSION, API_RUNTIME), - "cudaRuntimeGetVersion": ("hipRuntimeGetVersion", CONV_VERSION, API_RUNTIME, HIP_UNSUPPORTED), - "cudaOccupancyMaxPotentialBlockSize": ("hipOccupancyMaxPotentialBlockSize", CONV_OCCUPANCY, API_RUNTIME), - "cudaOccupancyMaxPotentialBlockSizeWithFlags": ("hipOccupancyMaxPotentialBlockSizeWithFlags", CONV_OCCUPANCY, API_RUNTIME, HIP_UNSUPPORTED), - "cudaOccupancyMaxActiveBlocksPerMultiprocessor": ("hipOccupancyMaxActiveBlocksPerMultiprocessor", CONV_OCCUPANCY, API_RUNTIME), - "cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags": ("hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags", CONV_OCCUPANCY, API_RUNTIME, HIP_UNSUPPORTED), - "cudaOccupancyMaxPotentialBlockSizeVariableSMem": ("hipOccupancyMaxPotentialBlockSizeVariableSMem", CONV_OCCUPANCY, API_RUNTIME, HIP_UNSUPPORTED), - "cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags": ("hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags", CONV_OCCUPANCY, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDeviceCanAccessPeer": ("hipDeviceCanAccessPeer", CONV_PEER, API_RUNTIME), - "cudaDeviceDisablePeerAccess": ("hipDeviceDisablePeerAccess", CONV_PEER, API_RUNTIME), - "cudaDeviceEnablePeerAccess": ("hipDeviceEnablePeerAccess", CONV_PEER, API_RUNTIME), - "cudaMemcpyPeerAsync": ("hipMemcpyPeerAsync", CONV_MEM, API_RUNTIME), - "cudaMemcpyPeer": ("hipMemcpyPeer", CONV_MEM, API_RUNTIME), - "cudaIpcMemLazyEnablePeerAccess": ("hipIpcMemLazyEnablePeerAccess", CONV_TYPE, API_RUNTIME), - "cudaDeviceSetSharedMemConfig": ("hipDeviceSetSharedMemConfig", CONV_DEVICE, API_RUNTIME), - "cudaDeviceGetSharedMemConfig": ("hipDeviceGetSharedMemConfig", CONV_DEVICE, API_RUNTIME), - "cudaSharedMemBankSizeDefault": ("hipSharedMemBankSizeDefault", CONV_TYPE, API_RUNTIME), - "cudaSharedMemBankSizeFourByte": ("hipSharedMemBankSizeFourByte", CONV_TYPE, API_RUNTIME), - "cudaSharedMemBankSizeEightByte": ("hipSharedMemBankSizeEightByte", CONV_TYPE, API_RUNTIME), - "cudaLimitStackSize": ("hipLimitStackSize", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaLimitPrintfFifoSize": ("hipLimitPrintfFifoSize", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaLimitMallocHeapSize": ("hipLimitMallocHeapSize", CONV_TYPE, API_RUNTIME), - "cudaLimitDevRuntimeSyncDepth": ("hipLimitDevRuntimeSyncDepth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaLimitDevRuntimePendingLaunchCount": ("hipLimitDevRuntimePendingLaunchCount", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDeviceGetLimit": ("hipDeviceGetLimit", CONV_DEVICE, API_RUNTIME), - "cudaProfilerInitialize": ("hipProfilerInitialize", CONV_OTHER, API_RUNTIME, HIP_UNSUPPORTED), - "cudaProfilerStart": ("hipProfilerStart", CONV_OTHER, API_RUNTIME), - "cudaProfilerStop": ("hipProfilerStop", CONV_OTHER, API_RUNTIME), - "cudaKeyValuePair": ("hipKeyValuePair", CONV_OTHER, API_RUNTIME, HIP_UNSUPPORTED), - "cudaCSV": ("hipCSV", CONV_OTHER, API_RUNTIME, HIP_UNSUPPORTED), - "cudaReadModeElementType": ("hipReadModeElementType", CONV_TEX, API_RUNTIME), - "cudaReadModeNormalizedFloat": ("hipReadModeNormalizedFloat", CONV_TEX, API_RUNTIME), - "cudaFilterModePoint": ("hipFilterModePoint", CONV_TEX, API_RUNTIME), - "cudaFilterModeLinear": ("hipFilterModeLinear", CONV_TEX, API_RUNTIME), - "cudaBindTexture": ("hipBindTexture", CONV_TEX, API_RUNTIME), - "cudaUnbindTexture": ("hipUnbindTexture", CONV_TEX, API_RUNTIME), - "cudaBindTexture2D": ("hipBindTexture2D", CONV_TEX, API_RUNTIME), - "cudaBindTextureToArray": ("hipBindTextureToArray", CONV_TEX, API_RUNTIME), - "cudaBindTextureToMipmappedArray": ("hipBindTextureToMipmappedArray", CONV_TEX, API_RUNTIME), - "cudaGetTextureAlignmentOffset": ("hipGetTextureAlignmentOffset", CONV_TEX, API_RUNTIME), - "cudaGetTextureReference": ("hipGetTextureReference", CONV_TEX, API_RUNTIME), - "cudaChannelFormatKindSigned": ("hipChannelFormatKindSigned", CONV_TEX, API_RUNTIME), - "cudaChannelFormatKindUnsigned": ("hipChannelFormatKindUnsigned", CONV_TEX, API_RUNTIME), - "cudaChannelFormatKindFloat": ("hipChannelFormatKindFloat", CONV_TEX, API_RUNTIME), - "cudaChannelFormatKindNone": ("hipChannelFormatKindNone", CONV_TEX, API_RUNTIME), - "cudaCreateChannelDesc": ("hipCreateChannelDesc", CONV_TEX, API_RUNTIME), - "cudaGetChannelDesc": ("hipGetChannelDesc", CONV_TEX, API_RUNTIME), - "cudaResourceTypeArray": ("hipResourceTypeArray", CONV_TEX, API_RUNTIME), - "cudaResourceTypeMipmappedArray": ("hipResourceTypeMipmappedArray", CONV_TEX, API_RUNTIME), - "cudaResourceTypeLinear": ("hipResourceTypeLinear", CONV_TEX, API_RUNTIME), - "cudaResourceTypePitch2D": ("hipResourceTypePitch2D", CONV_TEX, API_RUNTIME), - "cudaResViewFormatNone": ("hipResViewFormatNone", CONV_TEX, API_RUNTIME), - "cudaResViewFormatUnsignedChar1": ("hipResViewFormatUnsignedChar1", CONV_TEX, API_RUNTIME), - "cudaResViewFormatUnsignedChar2": ("hipResViewFormatUnsignedChar2", CONV_TEX, API_RUNTIME), - "cudaResViewFormatUnsignedChar4": ("hipResViewFormatUnsignedChar4", CONV_TEX, API_RUNTIME), - "cudaResViewFormatSignedChar1": ("hipResViewFormatSignedChar1", CONV_TEX, API_RUNTIME), - "cudaResViewFormatSignedChar2": ("hipResViewFormatSignedChar2", CONV_TEX, API_RUNTIME), - "cudaResViewFormatSignedChar4": ("hipResViewFormatSignedChar4", CONV_TEX, API_RUNTIME), - "cudaResViewFormatUnsignedShort1": ("hipResViewFormatUnsignedShort1", CONV_TEX, API_RUNTIME), - "cudaResViewFormatUnsignedShort2": ("hipResViewFormatUnsignedShort2", CONV_TEX, API_RUNTIME), - "cudaResViewFormatUnsignedShort4": ("hipResViewFormatUnsignedShort4", CONV_TEX, API_RUNTIME), - "cudaResViewFormatSignedShort1": ("hipResViewFormatSignedShort1", CONV_TEX, API_RUNTIME), - "cudaResViewFormatSignedShort2": ("hipResViewFormatSignedShort2", CONV_TEX, API_RUNTIME), - "cudaResViewFormatSignedShort4": ("hipResViewFormatSignedShort4", CONV_TEX, API_RUNTIME), - "cudaResViewFormatUnsignedInt1": ("hipResViewFormatUnsignedInt1", CONV_TEX, API_RUNTIME), - "cudaResViewFormatUnsignedInt2": ("hipResViewFormatUnsignedInt2", CONV_TEX, API_RUNTIME), - "cudaResViewFormatUnsignedInt4": ("hipResViewFormatUnsignedInt4", CONV_TEX, API_RUNTIME), - "cudaResViewFormatSignedInt1": ("hipResViewFormatSignedInt1", CONV_TEX, API_RUNTIME), - "cudaResViewFormatSignedInt2": ("hipResViewFormatSignedInt2", CONV_TEX, API_RUNTIME), - "cudaResViewFormatSignedInt4": ("hipResViewFormatSignedInt4", CONV_TEX, API_RUNTIME), - "cudaResViewFormatHalf1": ("hipResViewFormatHalf1", CONV_TEX, API_RUNTIME), - "cudaResViewFormatHalf2": ("hipResViewFormatHalf2", CONV_TEX, API_RUNTIME), - "cudaResViewFormatHalf4": ("hipResViewFormatHalf4", CONV_TEX, API_RUNTIME), - "cudaResViewFormatFloat1": ("hipResViewFormatFloat1", CONV_TEX, API_RUNTIME), - "cudaResViewFormatFloat2": ("hipResViewFormatFloat2", CONV_TEX, API_RUNTIME), - "cudaResViewFormatFloat4": ("hipResViewFormatFloat4", CONV_TEX, API_RUNTIME), - "cudaResViewFormatUnsignedBlockCompressed1": ("hipResViewFormatUnsignedBlockCompressed1", CONV_TEX, API_RUNTIME), - "cudaResViewFormatUnsignedBlockCompressed2": ("hipResViewFormatUnsignedBlockCompressed2", CONV_TEX, API_RUNTIME), - "cudaResViewFormatUnsignedBlockCompressed3": ("hipResViewFormatUnsignedBlockCompressed3", CONV_TEX, API_RUNTIME), - "cudaResViewFormatUnsignedBlockCompressed4": ("hipResViewFormatUnsignedBlockCompressed4", CONV_TEX, API_RUNTIME), - "cudaResViewFormatSignedBlockCompressed4": ("hipResViewFormatSignedBlockCompressed4", CONV_TEX, API_RUNTIME), - "cudaResViewFormatUnsignedBlockCompressed5": ("hipResViewFormatUnsignedBlockCompressed5", CONV_TEX, API_RUNTIME), - "cudaResViewFormatSignedBlockCompressed5": ("hipResViewFormatSignedBlockCompressed5", CONV_TEX, API_RUNTIME), - "cudaResViewFormatUnsignedBlockCompressed6H": ("hipResViewFormatUnsignedBlockCompressed6H", CONV_TEX, API_RUNTIME), - "cudaResViewFormatSignedBlockCompressed6H": ("hipResViewFormatSignedBlockCompressed6H", CONV_TEX, API_RUNTIME), - "cudaResViewFormatUnsignedBlockCompressed7": ("hipResViewFormatUnsignedBlockCompressed7", CONV_TEX, API_RUNTIME), - "cudaAddressModeWrap": ("hipAddressModeWrap", CONV_TEX, API_RUNTIME), - "cudaAddressModeClamp": ("hipAddressModeClamp", CONV_TEX, API_RUNTIME), - "cudaAddressModeMirror": ("hipAddressModeMirror", CONV_TEX, API_RUNTIME), - "cudaAddressModeBorder": ("hipAddressModeBorder", CONV_TEX, API_RUNTIME), - "cudaCreateTextureObject": ("hipCreateTextureObject", CONV_TEX, API_RUNTIME), - "cudaDestroyTextureObject": ("hipDestroyTextureObject", CONV_TEX, API_RUNTIME), - "cudaGetTextureObjectResourceDesc": ("hipGetTextureObjectResourceDesc", CONV_TEX, API_RUNTIME), - "cudaGetTextureObjectResourceViewDesc": ("hipGetTextureObjectResourceViewDesc", CONV_TEX, API_RUNTIME), - "cudaGetTextureObjectTextureDesc": ("hipGetTextureObjectTextureDesc", CONV_TEX, API_RUNTIME), - "cudaBindSurfaceToArray": ("hipBindSurfaceToArray", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGetSurfaceReference": ("hipGetSurfaceReference", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaBoundaryModeZero": ("hipBoundaryModeZero", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaBoundaryModeClamp": ("hipBoundaryModeClamp", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaBoundaryModeTrap": ("hipBoundaryModeTrap", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaFormatModeForced": ("hipFormatModeForced", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaFormatModeAuto": ("hipFormatModeAuto", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaCreateSurfaceObject": ("hipCreateSurfaceObject", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaDestroySurfaceObject": ("hipDestroySurfaceObject", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGetSurfaceObjectResourceDesc": ("hipGetSurfaceObjectResourceDesc", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED), - "cudaIpcCloseMemHandle": ("hipIpcCloseMemHandle", CONV_DEVICE, API_RUNTIME), - "cudaIpcGetEventHandle": ("hipIpcGetEventHandle", CONV_DEVICE, API_RUNTIME), - "cudaIpcGetMemHandle": ("hipIpcGetMemHandle", CONV_DEVICE, API_RUNTIME), - "cudaIpcOpenEventHandle": ("hipIpcOpenEventHandle", CONV_DEVICE, API_RUNTIME), - "cudaIpcOpenMemHandle": ("hipIpcOpenMemHandle", CONV_DEVICE, API_RUNTIME), - "cudaGLGetDevices": ("hipGLGetDevices", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsGLRegisterBuffer": ("hipGraphicsGLRegisterBuffer", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsGLRegisterImage": ("hipGraphicsGLRegisterImage", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED), - "cudaWGLGetDevice": ("hipWGLGetDevice", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsMapResources": ("hipGraphicsMapResources", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsResourceGetMappedMipmappedArray": ("hipGraphicsResourceGetMappedMipmappedArray", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsResourceGetMappedPointer": ("hipGraphicsResourceGetMappedPointer", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsResourceSetMapFlags": ("hipGraphicsResourceSetMapFlags", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsSubResourceGetMappedArray": ("hipGraphicsSubResourceGetMappedArray", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsUnmapResources": ("hipGraphicsUnmapResources", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsUnregisterResource": ("hipGraphicsUnregisterResource", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsCubeFacePositiveX": ("hipGraphicsCubeFacePositiveX", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsCubeFaceNegativeX": ("hipGraphicsCubeFaceNegativeX", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsCubeFacePositiveY": ("hipGraphicsCubeFacePositiveY", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsCubeFaceNegativeY": ("hipGraphicsCubeFaceNegativeY", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsCubeFacePositiveZ": ("hipGraphicsCubeFacePositiveZ", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsCubeFaceNegativeZ": ("hipGraphicsCubeFaceNegativeZ", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsMapFlagsNone": ("hipGraphicsMapFlagsNone", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsMapFlagsReadOnly": ("hipGraphicsMapFlagsReadOnly", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsMapFlagsWriteDiscard": ("hipGraphicsMapFlagsWriteDiscard", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsRegisterFlagsNone": ("hipGraphicsRegisterFlagsNone", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsRegisterFlagsReadOnly": ("hipGraphicsRegisterFlagsReadOnly", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsRegisterFlagsWriteDiscard": ("hipGraphicsRegisterFlagsWriteDiscard", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsRegisterFlagsSurfaceLoadStore": ("hipGraphicsRegisterFlagsSurfaceLoadStore", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsRegisterFlagsTextureGather": ("hipGraphicsRegisterFlagsTextureGather", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGLDeviceListAll": ("HIP_GL_DEVICE_LIST_ALL", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGLDeviceListCurrentFrame": ("HIP_GL_DEVICE_LIST_CURRENT_FRAME", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGLDeviceListNextFrame": ("HIP_GL_DEVICE_LIST_NEXT_FRAME", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGLGetDevices": ("hipGLGetDevices", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsGLRegisterBuffer": ("hipGraphicsGLRegisterBuffer", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsGLRegisterImage": ("hipGraphicsGLRegisterImage", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED), - "cudaWGLGetDevice": ("hipWGLGetDevice", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGLMapFlagsNone": ("HIP_GL_MAP_RESOURCE_FLAGS_NONE", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGLMapFlagsReadOnly": ("HIP_GL_MAP_RESOURCE_FLAGS_READ_ONLY", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGLMapFlagsWriteDiscard": ("HIP_GL_MAP_RESOURCE_FLAGS_WRITE_DISCARD", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGLMapBufferObject": ("hipGLMapBufferObject__", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGLMapBufferObjectAsync": ("hipGLMapBufferObjectAsync__", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGLRegisterBufferObject": ("hipGLRegisterBufferObject", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGLSetBufferObjectMapFlags": ("hipGLSetBufferObjectMapFlags", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGLSetGLDevice": ("hipGLSetGLDevice", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGLUnmapBufferObject": ("hipGLUnmapBufferObject", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGLUnmapBufferObjectAsync": ("hipGLUnmapBufferObjectAsync", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGLUnregisterBufferObject": ("hipGLUnregisterBufferObject", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D9DeviceListAll": ("HIP_D3D9_DEVICE_LIST_ALL", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D9DeviceListCurrentFrame": ("HIP_D3D9_DEVICE_LIST_CURRENT_FRAME", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D9DeviceListNextFrame": ("HIP_D3D9_DEVICE_LIST_NEXT_FRAME", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D9GetDevice": ("hipD3D9GetDevice", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D9GetDevices": ("hipD3D9GetDevices", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D9GetDirect3DDevice": ("hipD3D9GetDirect3DDevice", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D9SetDirect3DDevice": ("hipD3D9SetDirect3DDevice", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsD3D9RegisterResource": ("hipGraphicsD3D9RegisterResource", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D9MapFlags": ("hipD3D9MapFlags", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D9MapFlagsNone": ("HIP_D3D9_MAPRESOURCE_FLAGS_NONE", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D9MapFlagsReadOnly": ("HIP_D3D9_MAPRESOURCE_FLAGS_READONLY", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D9MapFlagsWriteDiscard": ("HIP_D3D9_MAPRESOURCE_FLAGS_WRITEDISCARD", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D9RegisterFlagsNone": ("HIP_D3D9_REGISTER_FLAGS_NONE", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D9RegisterFlagsArray": ("HIP_D3D9_REGISTER_FLAGS_ARRAY", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D9MapResources": ("hipD3D9MapResources", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D9RegisterResource": ("hipD3D9RegisterResource", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D9ResourceGetMappedArray": ("hipD3D9ResourceGetMappedArray", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D9ResourceGetMappedPitch": ("hipD3D9ResourceGetMappedPitch", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D9ResourceGetMappedPointer": ("hipD3D9ResourceGetMappedPointer", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D9ResourceGetMappedSize": ("hipD3D9ResourceGetMappedSize", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D9ResourceGetSurfaceDimensions": ("hipD3D9ResourceGetSurfaceDimensions", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D9ResourceSetMapFlags": ("hipD3D9ResourceSetMapFlags", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D9UnmapResources": ("hipD3D9UnmapResources", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D9UnregisterResource": ("hipD3D9UnregisterResource", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D10DeviceListAll": ("HIP_D3D10_DEVICE_LIST_ALL", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D10DeviceListCurrentFrame": ("HIP_D3D10_DEVICE_LIST_CURRENT_FRAME", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D10DeviceListNextFrame": ("HIP_D3D10_DEVICE_LIST_NEXT_FRAME", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D10GetDevice": ("hipD3D10GetDevice", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D10GetDevices": ("hipD3D10GetDevices", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsD3D10RegisterResource": ("hipGraphicsD3D10RegisterResource", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D10MapFlagsNone": ("HIP_D3D10_MAPRESOURCE_FLAGS_NONE", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D10MapFlagsReadOnly": ("HIP_D3D10_MAPRESOURCE_FLAGS_READONLY", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D10MapFlagsWriteDiscard": ("HIP_D3D10_MAPRESOURCE_FLAGS_WRITEDISCARD", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D10RegisterFlagsNone": ("HIP_D3D10_REGISTER_FLAGS_NONE", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D10RegisterFlagsArray": ("HIP_D3D10_REGISTER_FLAGS_ARRAY", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D10GetDirect3DDevice": ("hipD3D10GetDirect3DDevice", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D10MapResources": ("hipD3D10MapResources", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D10RegisterResource": ("hipD3D10RegisterResource", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D10ResourceGetMappedArray": ("hipD3D10ResourceGetMappedArray", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D10ResourceGetMappedPitch": ("hipD3D10ResourceGetMappedPitch", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D10ResourceGetMappedPointer": ("hipD3D10ResourceGetMappedPointer", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D10ResourceGetMappedSize": ("hipD3D10ResourceGetMappedSize", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D10ResourceGetSurfaceDimensions": ("hipD3D10ResourceGetSurfaceDimensions", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D10ResourceSetMapFlags": ("hipD3D10ResourceSetMapFlags", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D10SetDirect3DDevice": ("hipD3D10SetDirect3DDevice", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D10UnmapResources": ("hipD3D10UnmapResources", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D10UnregisterResource": ("hipD3D10UnregisterResource", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D11DeviceListAll": ("HIP_D3D11_DEVICE_LIST_ALL", CONV_D3D11, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D11DeviceListCurrentFrame": ("HIP_D3D11_DEVICE_LIST_CURRENT_FRAME", CONV_D3D11, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D11DeviceListNextFrame": ("HIP_D3D11_DEVICE_LIST_NEXT_FRAME", CONV_D3D11, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D11GetDevice": ("hipD3D11GetDevice", CONV_D3D11, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D11GetDevices": ("hipD3D11GetDevices", CONV_D3D11, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsD3D11RegisterResource": ("hipGraphicsD3D11RegisterResource", CONV_D3D11, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D11GetDevice": ("hipD3D11GetDevice", CONV_D3D11, API_RUNTIME, HIP_UNSUPPORTED), - "cudaD3D11GetDevices": ("hipD3D11GetDevices", CONV_D3D11, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsD3D11RegisterResource": ("hipGraphicsD3D11RegisterResource", CONV_D3D11, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsVDPAURegisterOutputSurface": ("hipGraphicsVDPAURegisterOutputSurface", CONV_VDPAU, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsVDPAURegisterVideoSurface": ("hipGraphicsVDPAURegisterVideoSurface", CONV_VDPAU, API_RUNTIME, HIP_UNSUPPORTED), - "cudaVDPAUGetDevice": ("hipVDPAUGetDevice", CONV_VDPAU, API_RUNTIME, HIP_UNSUPPORTED), - "cudaVDPAUSetVDPAUDevice": ("hipVDPAUSetDevice", CONV_VDPAU, API_RUNTIME, HIP_UNSUPPORTED), - "cudaEGLStreamConsumerAcquireFrame": ("hipEGLStreamConsumerAcquireFrame", CONV_EGL, API_RUNTIME, HIP_UNSUPPORTED), - "cudaEGLStreamConsumerConnect": ("hipEGLStreamConsumerConnect", CONV_EGL, API_RUNTIME, HIP_UNSUPPORTED), - "cudaEGLStreamConsumerConnectWithFlags": ("hipEGLStreamConsumerConnectWithFlags", CONV_EGL, API_RUNTIME, HIP_UNSUPPORTED), - "cudaEGLStreamConsumerReleaseFrame": ("hipEGLStreamConsumerReleaseFrame", CONV_EGL, API_RUNTIME, HIP_UNSUPPORTED), - "cudaEGLStreamProducerConnect": ("hipEGLStreamProducerConnect", CONV_EGL, API_RUNTIME, HIP_UNSUPPORTED), - "cudaEGLStreamProducerDisconnect": ("hipEGLStreamProducerDisconnect", CONV_EGL, API_RUNTIME, HIP_UNSUPPORTED), - "cudaEGLStreamProducerPresentFrame": ("hipEGLStreamProducerPresentFrame", CONV_EGL, API_RUNTIME, HIP_UNSUPPORTED), - "cudaEGLStreamProducerReturnFrame": ("hipEGLStreamProducerReturnFrame", CONV_EGL, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsEGLRegisterImage": ("hipGraphicsEGLRegisterImage", CONV_EGL, API_RUNTIME, HIP_UNSUPPORTED), - "cudaGraphicsResourceGetMappedEglFrame": ("hipGraphicsResourceGetMappedEglFrame", CONV_EGL, API_RUNTIME, HIP_UNSUPPORTED), - "cublasInit": ("rocblas_init", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasShutdown": ("rocblas_shutdown", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasGetVersion": ("rocblas_get_version", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasGetError": ("rocblas_get_error", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasAlloc": ("rocblas_alloc", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasFree": ("rocblas_free", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSetKernelStream": ("rocblas_set_kernel_stream", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasGetAtomicsMode": ("rocblas_get_atomics_mode", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSetAtomicsMode": ("rocblas_set_atomics_mode", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasGetMathMode": ("rocblas_get_math_mode", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSetMathMode": ("rocblas_set_math_mode", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "CUBLAS_OP_N": ("rocblas_operation_none", CONV_NUMERIC_LITERAL, API_BLAS), - "CUBLAS_OP_T": ("rocblas_operation_transpose", CONV_NUMERIC_LITERAL, API_BLAS), - "CUBLAS_OP_C": ("rocblas_operation_conjugate_transpose", CONV_NUMERIC_LITERAL, API_BLAS), - "CUBLAS_STATUS_SUCCESS": ("rocblas_status_success", CONV_NUMERIC_LITERAL, API_BLAS), - "CUBLAS_STATUS_NOT_INITIALIZED": ("rocblas_status_invalid_handle", CONV_NUMERIC_LITERAL, API_BLAS), - "CUBLAS_STATUS_ALLOC_FAILED": ("rocblas_status_memory_error", CONV_NUMERIC_LITERAL, API_BLAS), - "CUBLAS_STATUS_INVALID_VALUE": ("rocblas_status_invalid_pointer", CONV_NUMERIC_LITERAL, API_BLAS), - "CUBLAS_STATUS_MAPPING_ERROR": ("rocblas_status_internal_error", CONV_NUMERIC_LITERAL, API_BLAS), - "CUBLAS_STATUS_EXECUTION_FAILED": ("rocblas_status_internal_error", CONV_NUMERIC_LITERAL, API_BLAS), - "CUBLAS_STATUS_INTERNAL_ERROR": ("rocblas_status_internal_error", CONV_NUMERIC_LITERAL, API_BLAS), - "CUBLAS_STATUS_NOT_SUPPORTED": ("rocblas_status_not_implemented", CONV_NUMERIC_LITERAL, API_BLAS), - "CUBLAS_STATUS_ARCH_MISMATCH": ("rocblas_status_not_implemented", CONV_NUMERIC_LITERAL, API_BLAS), - "CUBLAS_FILL_MODE_LOWER": ("rocblas_fill_lower", CONV_NUMERIC_LITERAL, API_BLAS), - "CUBLAS_FILL_MODE_UPPER": ("rocblas_fill_upper", CONV_NUMERIC_LITERAL, API_BLAS), - "CUBLAS_DIAG_NON_UNIT": ("rocblas_diagonal_non_unit", CONV_NUMERIC_LITERAL, API_BLAS), - "CUBLAS_DIAG_UNIT": ("rocblas_diagonal_unit", CONV_NUMERIC_LITERAL, API_BLAS), - "CUBLAS_SIDE_LEFT": ("rocblas_side_left", CONV_NUMERIC_LITERAL, API_BLAS), - "CUBLAS_SIDE_RIGHT": ("rocblas_side_right", CONV_NUMERIC_LITERAL, API_BLAS), - "CUBLAS_POINTER_MODE_HOST": ("rocblas_pointer_mode_host", CONV_NUMERIC_LITERAL, API_BLAS), - "CUBLAS_POINTER_MODE_DEVICE": ("rocblas_pointer_mode_device", CONV_NUMERIC_LITERAL, API_BLAS), - "CUBLAS_ATOMICS_NOT_ALLOWED": ("rocblas_atomics_not_allowed", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED), - "CUBLAS_ATOMICS_ALLOWED": ("rocblas_atomics_allowed", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED), - "CUBLAS_DATA_FLOAT": ("rocblas_precision_float", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED), - "CUBLAS_DATA_DOUBLE": ("rocblas_precision_double", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED), - "CUBLAS_DATA_HALF": ("rocblas_precision_half", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED), - "CUBLAS_DATA_INT8": ("rocblas_precision_int8", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED), - "cublasCreate": ("rocblas_create_handle", CONV_MATH_FUNC, API_BLAS), - "cublasDestroy": ("rocblas_destroy_handle", CONV_MATH_FUNC, API_BLAS), - "cublasSetVector": ("rocblas_set_vector", CONV_MATH_FUNC, API_BLAS), - "cublasGetVector": ("rocblas_get_vector", CONV_MATH_FUNC, API_BLAS), - "cublasSetVectorAsync": ("rocblas_set_vector_async", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasGetVectorAsync": ("rocblas_get_vector_async", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSetMatrix": ("rocblas_set_matrix", CONV_MATH_FUNC, API_BLAS), - "cublasGetMatrix": ("rocblas_get_matrix", CONV_MATH_FUNC, API_BLAS), - "cublasGetMatrixAsync": ("rocblas_get_matrix_async", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSetMatrixAsync": ("rocblas_set_matrix_async", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasXerbla": ("rocblas_xerbla", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSnrm2": ("rocblas_snrm2", CONV_MATH_FUNC, API_BLAS), - "cublasDnrm2": ("rocblas_dnrm2", CONV_MATH_FUNC, API_BLAS), - "cublasScnrm2": ("rocblas_scnrm2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDznrm2": ("rocblas_dznrm2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasNrm2Ex": ("rocblas_nrm2_ex", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSdot": ("rocblas_sdot", CONV_MATH_FUNC, API_BLAS), - "cublasSdotBatched": ("rocblas_sdot_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDdot": ("rocblas_ddot", CONV_MATH_FUNC, API_BLAS), - "cublasDdotBatched": ("rocblas_ddot_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCdotu": ("rocblas_cdotu", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCdotc": ("rocblas_cdotc", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZdotu": ("rocblas_zdotu", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZdotc": ("rocblas_zdotc", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSscal": ("rocblas_sscal", CONV_MATH_FUNC, API_BLAS), - "cublasSscalBatched": ("rocblas_sscal_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDscal": ("rocblas_dscal", CONV_MATH_FUNC, API_BLAS), - "cublasDscalBatched": ("rocblas_dscal_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCscal": ("rocblas_cscal", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCsscal": ("rocblas_csscal", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZscal": ("rocblas_zscal", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZdscal": ("rocblas_zdscal", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSaxpy": ("rocblas_saxpy", CONV_MATH_FUNC, API_BLAS), - "cublasSaxpyBatched": ("rocblas_saxpy_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDaxpy": ("rocblas_daxpy", CONV_MATH_FUNC, API_BLAS), - "cublasCaxpy": ("rocblas_caxpy", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZaxpy": ("rocblas_zaxpy", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasScopy": ("rocblas_scopy", CONV_MATH_FUNC, API_BLAS), - "cublasScopyBatched": ("rocblas_scopy_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDcopy": ("rocblas_dcopy", CONV_MATH_FUNC, API_BLAS), - "cublasDcopyBatched": ("rocblas_dcopy_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCcopy": ("rocblas_ccopy", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZcopy": ("rocblas_zcopy", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSswap": ("rocblas_sswap", CONV_MATH_FUNC, API_BLAS), - "cublasDswap": ("rocblas_dswap", CONV_MATH_FUNC, API_BLAS), - "cublasCswap": ("rocblas_cswap", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZswap": ("rocblas_zswap", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasIsamax": ("rocblas_isamax", CONV_MATH_FUNC, API_BLAS), - "cublasIdamax": ("rocblas_idamax", CONV_MATH_FUNC, API_BLAS), - "cublasIcamax": ("rocblas_icamax", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasIzamax": ("rocblas_izamax", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasIsamin": ("rocblas_isamin", CONV_MATH_FUNC, API_BLAS), - "cublasIdamin": ("rocblas_idamin", CONV_MATH_FUNC, API_BLAS), - "cublasIcamin": ("rocblas_icamin", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasIzamin": ("rocblas_izamin", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSasum": ("rocblas_sasum", CONV_MATH_FUNC, API_BLAS), - "cublasSasumBatched": ("rocblas_sasum_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDasum": ("rocblas_dasum", CONV_MATH_FUNC, API_BLAS), - "cublasDasumBatched": ("rocblas_dasum_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasScasum": ("rocblas_scasum", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDzasum": ("rocblas_dzasum", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSrot": ("rocblas_srot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDrot": ("rocblas_drot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCrot": ("rocblas_crot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCsrot": ("rocblas_csrot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZrot": ("rocblas_zrot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZdrot": ("rocblas_zdrot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSrotg": ("rocblas_srotg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDrotg": ("rocblas_drotg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCrotg": ("rocblas_crotg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZrotg": ("rocblas_zrotg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSrotm": ("rocblas_srotm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDrotm": ("rocblas_drotm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSrotmg": ("rocblas_srotmg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDrotmg": ("rocblas_drotmg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSgemv": ("rocblas_sgemv", CONV_MATH_FUNC, API_BLAS), - "cublasSgemvBatched": ("rocblas_sgemv_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDgemv": ("rocblas_dgemv", CONV_MATH_FUNC, API_BLAS), - "cublasCgemv": ("rocblas_cgemv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZgemv": ("rocblas_zgemv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSgbmv": ("rocblas_sgbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDgbmv": ("rocblas_dgbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCgbmv": ("rocblas_cgbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZgbmv": ("rocblas_zgbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasStrmv": ("rocblas_strmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDtrmv": ("rocblas_dtrmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCtrmv": ("rocblas_ctrmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZtrmv": ("rocblas_ztrmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasStbmv": ("rocblas_stbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDtbmv": ("rocblas_dtbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCtbmv": ("rocblas_ctbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZtbmv": ("rocblas_ztbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasStpmv": ("rocblas_stpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDtpmv": ("rocblas_dtpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCtpmv": ("rocblas_ctpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZtpmv": ("rocblas_ztpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasStrsv": ("rocblas_strsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDtrsv": ("rocblas_dtrsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCtrsv": ("rocblas_ctrsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZtrsv": ("rocblas_ztrsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasStpsv": ("rocblas_stpsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDtpsv": ("rocblas_dtpsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCtpsv": ("rocblas_ctpsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZtpsv": ("rocblas_ztpsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasStbsv": ("rocblas_stbsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDtbsv": ("rocblas_dtbsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCtbsv": ("rocblas_ctbsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZtbsv": ("rocblas_ztbsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSsymv": ("rocblas_ssymv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDsymv": ("rocblas_dsymv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCsymv": ("rocblas_csymv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZsymv": ("rocblas_zsymv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasChemv": ("rocblas_chemv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZhemv": ("rocblas_zhemv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSsbmv": ("rocblas_ssbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDsbmv": ("rocblas_dsbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasChbmv": ("rocblas_chbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZhbmv": ("rocblas_zhbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSspmv": ("rocblas_sspmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDspmv": ("rocblas_dspmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasChpmv": ("rocblas_chpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZhpmv": ("rocblas_zhpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSger": ("rocblas_sger", CONV_MATH_FUNC, API_BLAS), - "cublasDger": ("rocblas_dger", CONV_MATH_FUNC, API_BLAS), - "cublasCgeru": ("rocblas_cgeru", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCgerc": ("rocblas_cgerc", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZgeru": ("rocblas_zgeru", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZgerc": ("rocblas_zgerc", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSsyr": ("rocblas_ssyr", CONV_MATH_FUNC, API_BLAS), - "cublasDsyr": ("rocblas_dsyr", CONV_MATH_FUNC, API_BLAS), - "cublasCher": ("rocblas_cher", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZher": ("rocblas_zher", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSspr": ("rocblas_sspr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDspr": ("rocblas_dspr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasChpr": ("rocblas_chpr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZhpr": ("rocblas_zhpr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSsyr2": ("rocblas_ssyr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDsyr2": ("rocblas_dsyr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCher2": ("rocblas_cher2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZher2": ("rocblas_zher2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSspr2": ("rocblas_sspr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDspr2": ("rocblas_dspr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasChpr2": ("rocblas_chpr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZhpr2": ("rocblas_zhpr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSgemm": ("rocblas_sgemm", CONV_MATH_FUNC, API_BLAS), - "cublasDgemm": ("rocblas_dgemm", CONV_MATH_FUNC, API_BLAS), - "cublasCgemm": ("rocblas_cgemm", CONV_MATH_FUNC, API_BLAS), - "cublasZgemm": ("rocblas_zgemm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasHgemm": ("rocblas_hgemm", CONV_MATH_FUNC, API_BLAS), - "cublasSgemmBatched": ("rocblas_sgemm_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDgemmBatched": ("rocblas_dgemm_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasHgemmBatched": ("rocblas_hgemm_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSgemmStridedBatched": ("rocblas_sgemm_strided_batched", CONV_MATH_FUNC, API_BLAS), - "cublasDgemmStridedBatched": ("rocblas_dgemm_strided_batched", CONV_MATH_FUNC, API_BLAS), - "cublasHgemmStridedBatched": ("rocblas_hgemm_strided_batched", CONV_MATH_FUNC, API_BLAS), - "cublasCgemmBatched": ("rocblas_cgemm_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCgemm3mBatched": ("rocblas_cgemm_3m_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZgemmBatched": ("rocblas_zgemm_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCgemmStridedBatched": ("rocblas_cgemm_strided_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCgemm3mStridedBatched": ("rocblas_cgemm_3m_strided_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZgemmStridedBatched": ("rocblas_zgemm_strided_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasHgemmStridedBatched": ("rocblas_hgemm_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSsyrk": ("rocblas_ssyrk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDsyrk": ("rocblas_dsyrk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCsyrk": ("rocblas_csyrk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZsyrk": ("rocblas_zsyrk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCherk": ("rocblas_cherk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZherk": ("rocblas_zherk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSsyr2k": ("rocblas_ssyr2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDsyr2k": ("rocblas_dsyr2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCsyr2k": ("rocblas_csyr2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZsyr2k": ("rocblas_zyr2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSsyrkx": ("rocblas_ssyrkx", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDsyrkx": ("rocblas_dsyrkx", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCsyrkx": ("rocblas_csyrkx", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZsyrkx": ("rocblas_zsyrkx", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCher2k": ("rocblas_cher2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZher2k": ("rocblas_zher2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCherkx": ("rocblas_cherkx", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZherkx": ("rocblas_zherkx", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSsymm": ("rocblas_ssymm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDsymm": ("rocblas_dsymm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCsymm": ("rocblas_csymm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZsymm": ("rocblas_zsymm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasChemm": ("rocblas_chemm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZhemm": ("rocblas_zhemm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasStrsm": ("rocblas_strsm", CONV_MATH_FUNC, API_BLAS), - "cublasDtrsm": ("rocblas_dtrsm", CONV_MATH_FUNC, API_BLAS), - "cublasCtrsm": ("rocblas_ctrsm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZtrsm": ("rocblas_ztrsm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasStrsmBatched": ("rocblas_strsm_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDtrsmBatched": ("rocblas_dtrsm_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCtrsmBatched": ("rocblas_ctrsm_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZtrsmBatched": ("rocblas_ztrsm_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasStrmm": ("rocblas_strmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDtrmm": ("rocblas_dtrmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCtrmm": ("rocblas_ctrmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZtrmm": ("rocblas_ztrmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSgeam": ("rocblas_sgeam", CONV_MATH_FUNC, API_BLAS), - "cublasDgeam": ("rocblas_dgeam", CONV_MATH_FUNC, API_BLAS), - "cublasCgeam": ("rocblas_cgeam", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZgeam": ("rocblas_zgeam", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSgetrfBatched": ("rocblas_sgetrf_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDgetrfBatched": ("rocblas_dgetrf_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCgetrfBatched": ("rocblas_cgetrf_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZgetrfBatched": ("rocblas_zgetrf_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSgetriBatched": ("rocblas_sgetri_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDgetriBatched": ("rocblas_dgetri_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCgetriBatched": ("rocblas_cgetri_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZgetriBatched": ("rocblas_zgetri_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSgetrsBatched": ("rocblas_sgetrs_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDgetrsBatched": ("rocblas_dgetrs_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCgetrsBatched": ("rocblas_cgetrs_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZgetrsBatched": ("rocblas_zgetrs_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasStrsmBatched": ("rocblas_strsm_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDtrsmBatched": ("rocblas_dtrsm_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCtrsmBatched": ("rocblas_ctrsm_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZtrsmBatched": ("rocblas_dtrsm_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSmatinvBatched": ("rocblas_smatinv_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDmatinvBatched": ("rocblas_dmatinv_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCmatinvBatched": ("rocblas_cmatinv_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZmatinvBatched": ("rocblas_zmatinv_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSgeqrfBatched": ("rocblas_sgeqrf_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDgeqrfBatched": ("rocblas_dgeqrf_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCgeqrfBatched": ("rocblas_cgeqrf_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZgeqrfBatched": ("rocblas_zgeqrf_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSgelsBatched": ("rocblas_sgels_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDgelsBatched": ("rocblas_dgels_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCgelsBatched": ("rocblas_cgels_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZgelsBatched": ("rocblas_zgels_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSdgmm": ("rocblas_sdgmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDdgmm": ("rocblas_ddgmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCdgmm": ("rocblas_cdgmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZdgmm": ("rocblas_zdgmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasStpttr": ("rocblas_stpttr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDtpttr": ("rocblas_dtpttr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCtpttr": ("rocblas_ctpttr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZtpttr": ("rocblas_ztpttr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasStrttp": ("rocblas_strttp", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDtrttp": ("rocblas_dtrttp", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCtrttp": ("rocblas_ctrttp", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZtrttp": ("rocblas_ztrttp", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCreate_v2": ("rocblas_create_handle", CONV_MATH_FUNC, API_BLAS), - "cublasDestroy_v2": ("rocblas_destroy_handle", CONV_MATH_FUNC, API_BLAS), - "cublasGetVersion_v2": ("rocblas_get_version", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSetStream": ("rocblas_set_stream", CONV_MATH_FUNC, API_BLAS), - "cublasGetStream": ("rocblas_get_stream", CONV_MATH_FUNC, API_BLAS), - "cublasSetStream_v2": ("rocblas_set_stream", CONV_MATH_FUNC, API_BLAS), - "cublasGetStream_v2": ("rocblas_get_stream", CONV_MATH_FUNC, API_BLAS), - "cublasGetPointerMode_v2": ("rocblas_get_pointer_mode", CONV_MATH_FUNC, API_BLAS), - "cublasSetPointerMode_v2": ("rocblas_set_pointer_mode", CONV_MATH_FUNC, API_BLAS), - "cublasSgemv_v2": ("rocblas_sgemv", CONV_MATH_FUNC, API_BLAS), - "cublasDgemv_v2": ("rocblas_dgemv", CONV_MATH_FUNC, API_BLAS), - "cublasCgemv_v2": ("rocblas_cgemv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZgemv_v2": ("rocblas_zgemv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSgbmv_v2": ("rocblas_sgbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDgbmv_v2": ("rocblas_dgbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCgbmv_v2": ("rocblas_cgbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZgbmv_v2": ("rocblas_zgbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasStrmv_v2": ("rocblas_strmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDtrmv_v2": ("rocblas_dtrmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCtrmv_v2": ("rocblas_ctrmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZtrmv_v2": ("rocblas_ztrmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasStbmv_v2": ("rocblas_stbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDtbmv_v2": ("rocblas_dtbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCtbmv_v2": ("rocblas_ctbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZtbmv_v2": ("rocblas_ztbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasStpmv_v2": ("rocblas_stpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDtpmv_v2": ("rocblas_dtpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCtpmv_v2": ("rocblas_ctpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZtpmv_v2": ("rocblas_ztpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasStrsv_v2": ("rocblas_strsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDtrsv_v2": ("rocblas_dtrsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCtrsv_v2": ("rocblas_ctrsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZtrsv_v2": ("rocblas_ztrsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasStpsv_v2": ("rocblas_stpsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDtpsv_v2": ("rocblas_dtpsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCtpsv_v2": ("rocblas_ctpsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZtpsv_v2": ("rocblas_ztpsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasStbsv_v2": ("rocblas_stbsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDtbsv_v2": ("rocblas_dtbsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCtbsv_v2": ("rocblas_ctbsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZtbsv_v2": ("rocblas_ztbsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSsymv_v2": ("rocblas_ssymv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDsymv_v2": ("rocblas_dsymv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCsymv_v2": ("rocblas_csymv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZsymv_v2": ("rocblas_zsymv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasChemv_v2": ("rocblas_chemv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZhemv_v2": ("rocblas_zhemv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSsbmv_v2": ("rocblas_ssbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDsbmv_v2": ("rocblas_dsbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasChbmv_v2": ("rocblas_chbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZhbmv_v2": ("rocblas_zhbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSspmv_v2": ("rocblas_sspmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDspmv_v2": ("rocblas_dspmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasChpmv_v2": ("rocblas_chpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZhpmv_v2": ("rocblas_zhpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSger_v2": ("rocblas_sger", CONV_MATH_FUNC, API_BLAS), - "cublasDger_v2": ("rocblas_dger", CONV_MATH_FUNC, API_BLAS), - "cublasCgeru_v2": ("rocblas_cgeru", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCgerc_v2": ("rocblas_cergc", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZgeru_v2": ("rocblas_zgeru", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZgerc_v2": ("rocblas_zgerc", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSsyr_v2": ("rocblas_ssyr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDsyr_v2": ("rocblas_dsyr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCsyr_v2": ("rocblas_csyr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZsyr_v2": ("rocblas_zsyr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCher_v2": ("rocblas_cher", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZher_v2": ("rocblas_zher", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSspr_v2": ("rocblas_sspr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDspr_v2": ("rocblas_dspr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasChpr_v2": ("rocblas_chpr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZhpr_v2": ("rocblas_zhpr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSsyr2_v2": ("rocblas_ssyr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDsyr2_v2": ("rocblas_dsyr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCsyr2_v2": ("rocblas_csyr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZsyr2_v2": ("rocblas_zsyr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCher2_v2": ("rocblas_cher2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZher2_v2": ("rocblas_zher2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSspr2_v2": ("rocblas_sspr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDspr2_v2": ("rocblas_dspr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasChpr2_v2": ("rocblas_chpr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZhpr2_v2": ("rocblas_zhpr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSgemm_v2": ("rocblas_sgemm", CONV_MATH_FUNC, API_BLAS), - "cublasDgemm_v2": ("rocblas_dgemm", CONV_MATH_FUNC, API_BLAS), - "cublasCgemm_v2": ("rocblas_cgemm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCgemm3m": ("rocblas_cgemm_3m", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCgemm3mEx": ("rocblas_cgemm_3mex", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZgemm_v2": ("rocblas_zgemm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZgemm3m": ("rocblas_zgemm_3m", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSgemmEx": ("rocblas_sgemmex", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasGemmEx": ("rocblas_gemmex", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCgemmEx": ("rocblas_cgemmex", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasUint8gemmBias": ("rocblas_uint8gemmbias", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSsyrk_v2": ("rocblas_ssyrk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDsyrk_v2": ("rocblas_dsyrk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCsyrk_v2": ("rocblas_csyrk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZsyrk_v2": ("rocblas_zsyrk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCsyrkEx": ("rocblas_csyrkex", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCsyrk3mEx": ("rocblas_csyrk3mex", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCherk_v2": ("rocblas_cherk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCherkEx": ("rocblas_cherkex", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCherk3mEx": ("rocblas_cherk3mex", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZherk_v2": ("rocblas_zherk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSsyr2k_v2": ("rocblas_ssyr2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDsyr2k_v2": ("rocblas_dsyr2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCsyr2k_v2": ("rocblas_csyr2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZsyr2k_v2": ("rocblas_zsyr2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCher2k_v2": ("rocblas_cher2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZher2k_v2": ("rocblas_zher2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSsymm_v2": ("rocblas_ssymm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDsymm_v2": ("rocblas_dsymm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCsymm_v2": ("rocblas_csymm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZsymm_v2": ("rocblas_zsymm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasChemm_v2": ("rocblas_chemm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZhemm_v2": ("rocblas_zhemm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasStrsm_v2": ("rocblas_strsm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDtrsm_v2": ("rocblas_dtrsm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCtrsm_v2": ("rocblas_ctrsm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZtrsm_v2": ("rocblas_ztrsm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasStrmm_v2": ("rocblas_strmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDtrmm_v2": ("rocblas_dtrmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCtrmm_v2": ("rocblas_ctrmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZtrmm_v2": ("rocblas_ztrmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSnrm2_v2": ("rocblas_snrm2", CONV_MATH_FUNC, API_BLAS), - "cublasDnrm2_v2": ("rocblas_dnrm2", CONV_MATH_FUNC, API_BLAS), - "cublasScnrm2_v2": ("rocblas_scnrm2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDznrm2_v2": ("rocblas_dznrm2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDotEx": ("rocblas_dotex", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDotcEx": ("rocblas_dotcex", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSdot_v2": ("rocblas_sdot", CONV_MATH_FUNC, API_BLAS), - "cublasDdot_v2": ("rocblas_ddot", CONV_MATH_FUNC, API_BLAS), - "cublasCdotu_v2": ("rocblas_cdotu", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCdotc_v2": ("rocblas_cdotc", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZdotu_v2": ("rocblas_zdotu", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZdotc_v2": ("rocblas_zdotc", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasScalEx": ("rocblas_scalex", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSscal_v2": ("rocblas_sscal", CONV_MATH_FUNC, API_BLAS), - "cublasDscal_v2": ("rocblas_dscal", CONV_MATH_FUNC, API_BLAS), - "cublasCscal_v2": ("rocblas_cscal", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCsscal_v2": ("rocblas_csscal", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZscal_v2": ("rocblas_zcsal", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZdscal_v2": ("rocblas_zdscal", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasAxpyEx": ("rocblas_axpyex", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSaxpy_v2": ("rocblas_saxpy", CONV_MATH_FUNC, API_BLAS), - "cublasDaxpy_v2": ("rocblas_daxpy", CONV_MATH_FUNC, API_BLAS), - "cublasCaxpy_v2": ("rocblas_caxpy", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZaxpy_v2": ("rocblas_zaxpy", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasScopy_v2": ("rocblas_scopy", CONV_MATH_FUNC, API_BLAS), - "cublasDcopy_v2": ("rocblas_dcopy", CONV_MATH_FUNC, API_BLAS), - "cublasCcopy_v2": ("rocblas_ccopy", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZcopy_v2": ("rocblas_zcopy", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSswap_v2": ("rocblas_sswap", CONV_MATH_FUNC, API_BLAS), - "cublasDswap_v2": ("rocblas_dswap", CONV_MATH_FUNC, API_BLAS), - "cublasCswap_v2": ("rocblas_cswap", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZswap_v2": ("rocblas_zswap", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasIsamax_v2": ("rocblas_isamax", CONV_MATH_FUNC, API_BLAS), - "cublasIdamax_v2": ("rocblas_idamax", CONV_MATH_FUNC, API_BLAS), - "cublasIcamax_v2": ("rocblas_icamax", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasIzamax_v2": ("rocblas_izamax", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasIsamin_v2": ("rocblas_isamin", CONV_MATH_FUNC, API_BLAS), - "cublasIdamin_v2": ("rocblas_idamin", CONV_MATH_FUNC, API_BLAS), - "cublasIcamin_v2": ("rocblas_icamin", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasIzamin_v2": ("rocblas_izamin", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSasum_v2": ("rocblas_sasum", CONV_MATH_FUNC, API_BLAS), - "cublasDasum_v2": ("rocblas_dasum", CONV_MATH_FUNC, API_BLAS), - "cublasScasum_v2": ("rocblas_scasum", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDzasum_v2": ("rocblas_dzasum", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSrot_v2": ("rocblas_srot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDrot_v2": ("rocblas_drot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCrot_v2": ("rocblas_crot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCsrot_v2": ("rocblas_csrot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZrot_v2": ("rocblas_zrot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZdrot_v2": ("rocblas_zdrot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSrotg_v2": ("rocblas_srotg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDrotg_v2": ("rocblas_drotg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasCrotg_v2": ("rocblas_crotg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasZrotg_v2": ("rocblas_zrotg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSrotm_v2": ("rocblas_srotm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDrotm_v2": ("rocblas_drotm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasSrotmg_v2": ("rocblas_srotmg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "cublasDrotmg_v2": ("rocblas_drotmg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED), - "CURAND_STATUS_SUCCESS": ("HIPRAND_STATUS_SUCCESS", CONV_NUMERIC_LITERAL, API_RAND), - "curand_STATUS_VERSION_MISMATCH": ("HIPRAND_STATUS_VERSION_MISMATCH", CONV_NUMERIC_LITERAL, API_RAND), - "curand_STATUS_NOT_INITIALIZED": ("HIPRAND_STATUS_NOT_INITIALIZED", CONV_NUMERIC_LITERAL, API_RAND), - "curand_STATUS_ALLOCATION_FAILED": ("HIPRAND_STATUS_ALLOCATION_FAILED", CONV_NUMERIC_LITERAL, API_RAND), - "curand_STATUS_TYPE_ERROR": ("HIPRAND_STATUS_TYPE_ERROR", CONV_NUMERIC_LITERAL, API_RAND), - "curand_STATUS_OUT_OF_RANGE": ("HIPRAND_STATUS_OUT_OF_RANGE", CONV_NUMERIC_LITERAL, API_RAND), - "curand_STATUS_LENGTH_NOT_MULTIPLE": ("HIPRAND_STATUS_LENGTH_NOT_MULTIPLE", CONV_NUMERIC_LITERAL, API_RAND), - "curand_STATUS_DOUBLE_PRECISION_REQUIRED": ("HIPRAND_STATUS_DOUBLE_PRECISION_REQUIRED", CONV_NUMERIC_LITERAL, API_RAND), - "curand_STATUS_LAUNCH_FAILURE": ("HIPRAND_STATUS_LAUNCH_FAILURE", CONV_NUMERIC_LITERAL, API_RAND), - "curand_STATUS_PREEXISTING_FAILURE": ("HIPRAND_STATUS_PREEXISTING_FAILURE", CONV_NUMERIC_LITERAL, API_RAND), - "curand_STATUS_INITIALIZATION_FAILED": ("HIPRAND_STATUS_INITIALIZATION_FAILED", CONV_NUMERIC_LITERAL, API_RAND), - "curand_STATUS_ARCH_MISMATCH": ("HIPRAND_STATUS_ARCH_MISMATCH", CONV_NUMERIC_LITERAL, API_RAND), - "curand_STATUS_INTERNAL_ERROR": ("HIPRAND_STATUS_INTERNAL_ERROR", CONV_NUMERIC_LITERAL, API_RAND), - "curand_RNG_TEST": ("HIPRAND_RNG_TEST", CONV_NUMERIC_LITERAL, API_RAND), - "mtgp32dc_params_fast_11213": ("mtgp32dc_params_fast_11213", CONV_NUMERIC_LITERAL, API_RAND), - "curand_RNG_PSEUDO_DEFAULT": ("HIPRAND_RNG_PSEUDO_DEFAULT", CONV_NUMERIC_LITERAL, API_RAND), - "curand_RNG_PSEUDO_XORWOW": ("HIPRAND_RNG_PSEUDO_XORWOW", CONV_NUMERIC_LITERAL, API_RAND), - "curand_RNG_PSEUDO_MRG32K3A": ("HIPRAND_RNG_PSEUDO_MRG32K3A", CONV_NUMERIC_LITERAL, API_RAND), - "curand_RNG_PSEUDO_MTGP32": ("HIPRAND_RNG_PSEUDO_MTGP32", CONV_NUMERIC_LITERAL, API_RAND), - "curand_RNG_PSEUDO_MT19937": ("HIPRAND_RNG_PSEUDO_MT19937", CONV_NUMERIC_LITERAL, API_RAND), - "curand_RNG_PSEUDO_PHILOX4_32_10": ("HIPRAND_RNG_PSEUDO_PHILOX4_32_10", CONV_NUMERIC_LITERAL, API_RAND), - "curand_RNG_QUASI_DEFAULT": ("HIPRAND_RNG_QUASI_DEFAULT", CONV_NUMERIC_LITERAL, API_RAND), - "curand_RNG_QUASI_SOBOL32": ("HIPRAND_RNG_QUASI_SOBOL32", CONV_NUMERIC_LITERAL, API_RAND), - "curand_RNG_QUASI_SCRAMBLED_SOBOL32": ("HIPRAND_RNG_QUASI_SCRAMBLED_SOBOL32", CONV_NUMERIC_LITERAL, API_RAND), - "curand_RNG_QUASI_SOBOL64": ("HIPRAND_RNG_QUASI_SOBOL64", CONV_NUMERIC_LITERAL, API_RAND), - "curand_RNG_QUASI_SCRAMBLED_SOBOL64": ("HIPRAND_RNG_QUASI_SCRAMBLED_SOBOL64", CONV_NUMERIC_LITERAL, API_RAND), - "curand_ORDERING_PSEUDO_BEST": ("HIPRAND_ORDERING_PSEUDO_BEST", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED), - "curand_ORDERING_PSEUDO_DEFAULT": ("HIPRAND_ORDERING_PSEUDO_DEFAULT", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED), - "curand_ORDERING_PSEUDO_SEEDED": ("HIPRAND_ORDERING_PSEUDO_SEEDED", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED), - "curand_ORDERING_QUASI_DEFAULT": ("HIPRAND_ORDERING_QUASI_DEFAULT", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED), - "curand_DIRECTION_VECTORS_32_JOEKUO6": ("HIPRAND_DIRECTION_VECTORS_32_JOEKUO6", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED), - "curand_SCRAMBLED_DIRECTION_VECTORS_32_JOEKUO6": ("HIPRAND_SCRAMBLED_DIRECTION_VECTORS_32_JOEKUO6", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED), - "curand_DIRECTION_VECTORS_64_JOEKUO6": ("HIPRAND_DIRECTION_VECTORS_64_JOEKUO6", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED), - "curand_SCRAMBLED_DIRECTION_VECTORS_64_JOEKUO6": ("HIPRAND_SCRAMBLED_DIRECTION_VECTORS_64_JOEKUO6", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED), - "curand_CHOOSE_BEST": ("HIPRAND_CHOOSE_BEST", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED), - "curand_ITR": ("HIPRAND_ITR", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED), - "curand_KNUTH": ("HIPRAND_KNUTH", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED), - "curand_HITR": ("HIPRAND_HITR", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED), - "curand_M1": ("HIPRAND_M1", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED), - "curand_M2": ("HIPRAND_M2", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED), - "curand_BINARY_SEARCH": ("HIPRAND_BINARY_SEARCH", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED), - "curand_DISCRETE_GAUSS": ("HIPRAND_DISCRETE_GAUSS", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED), - "curand_REJECTION": ("HIPRAND_REJECTION", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED), - "curand_DEVICE_API": ("HIPRAND_DEVICE_API", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED), - "curand_FAST_REJECTION": ("HIPRAND_FAST_REJECTION", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED), - "curand_3RD": ("HIPRAND_3RD", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED), - "curand_DEFINITION": ("HIPRAND_DEFINITION", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED), - "curand_POISSON": ("HIPRAND_POISSON", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED), - "curandCreateGenerator": ("hiprandCreateGenerator", CONV_MATH_FUNC, API_RAND), - "curandCreateGeneratorHost": ("hiprandCreateGeneratorHost", CONV_MATH_FUNC, API_RAND), - "curandCreatePoissonDistribution": ("hiprandCreatePoissonDistribution", CONV_MATH_FUNC, API_RAND), - "curandDestroyDistribution": ("hiprandDestroyDistribution", CONV_MATH_FUNC, API_RAND), - "curandDestroyGenerator": ("hiprandDestroyGenerator", CONV_MATH_FUNC, API_RAND), - "curandGenerate": ("hiprandGenerate", CONV_MATH_FUNC, API_RAND), - "curandGenerateLogNormal": ("hiprandGenerateLogNormal", CONV_MATH_FUNC, API_RAND), - "curandGenerateLogNormalDouble": ("hiprandGenerateLogNormalDouble", CONV_MATH_FUNC, API_RAND), - "curandGenerateLongLong": ("hiprandGenerateLongLong", CONV_MATH_FUNC, API_RAND, HIP_UNSUPPORTED), - "curandGenerateNormal": ("hiprandGenerateNormal", CONV_MATH_FUNC, API_RAND), - "curandGenerateNormalDouble": ("hiprandGenerateNormalDouble", CONV_MATH_FUNC, API_RAND), - "curandGeneratePoisson": ("hiprandGeneratePoisson", CONV_MATH_FUNC, API_RAND), - "curandGenerateSeeds": ("hiprandGenerateSeeds", CONV_MATH_FUNC, API_RAND), - "curandGenerateUniform": ("hiprandGenerateUniform", CONV_MATH_FUNC, API_RAND), - "curandGenerateUniformDouble": ("hiprandGenerateUniformDouble", CONV_MATH_FUNC, API_RAND), - "curandGetDirectionVectors32": ("hiprandGetDirectionVectors32", CONV_MATH_FUNC, API_RAND, HIP_UNSUPPORTED), - "curandGetDirectionVectors64": ("hiprandGetDirectionVectors64", CONV_MATH_FUNC, API_RAND, HIP_UNSUPPORTED), - "curandGetProperty": ("hiprandGetProperty", CONV_MATH_FUNC, API_RAND, HIP_UNSUPPORTED), - "curandGetScrambleConstants32": ("hiprandGetScrambleConstants32", CONV_MATH_FUNC, API_RAND, HIP_UNSUPPORTED), - "curandGetScrambleConstants64": ("hiprandGetScrambleConstants64", CONV_MATH_FUNC, API_RAND, HIP_UNSUPPORTED), - "curandGetVersion": ("hiprandGetVersion", CONV_MATH_FUNC, API_RAND), - "curandSetGeneratorOffset": ("hiprandSetGeneratorOffset", CONV_MATH_FUNC, API_RAND), - "curandSetGeneratorOrdering": ("hiprandSetGeneratorOrdering", CONV_MATH_FUNC, API_RAND, HIP_UNSUPPORTED), - "curandSetPseudoRandomGeneratorSeed": ("hiprandSetPseudoRandomGeneratorSeed", CONV_MATH_FUNC, API_RAND), - "curandSetQuasiRandomGeneratorDimensions": ("hiprandSetQuasiRandomGeneratorDimensions", CONV_MATH_FUNC, API_RAND), - "curandSetStream": ("hiprandSetStream", CONV_MATH_FUNC, API_RAND), - "curand": ("hiprand", CONV_DEVICE_FUNC, API_RAND), - "curand_init": ("hiprand_init", CONV_DEVICE_FUNC, API_RAND), - "curand_log_normal": ("hiprand_log_normal", CONV_DEVICE_FUNC, API_RAND), - "curand_log_normal_double": ("hiprand_log_normal_double", CONV_DEVICE_FUNC, API_RAND), - "curand_log_normal2": ("hiprand_log_normal2", CONV_DEVICE_FUNC, API_RAND), - "curand_log_normal2_double": ("hiprand_log_normal2_double", CONV_DEVICE_FUNC, API_RAND), - "curand_log_normal4": ("hiprand_log_normal4", CONV_DEVICE_FUNC, API_RAND), - "curand_log_normal4_double": ("hiprand_log_normal4_double", CONV_DEVICE_FUNC, API_RAND), - "curand_mtgp32_single": ("hiprand_mtgp32_single", CONV_DEVICE_FUNC, API_RAND, HIP_UNSUPPORTED), - "curand_mtgp32_single_specific": ("hiprand_mtgp32_single_specific", CONV_DEVICE_FUNC, API_RAND, HIP_UNSUPPORTED), - "curand_mtgp32_specific": ("hiprand_mtgp32_specific", CONV_DEVICE_FUNC, API_RAND, HIP_UNSUPPORTED), - "curand_normal": ("hiprand_normal", CONV_DEVICE_FUNC, API_RAND), - "curandMakeMTGP32Constants": ("hiprandMakeMTGP32Constants", CONV_DEVICE_FUNC, API_RAND), - "curandMakeMTGP32KernelState": ("hiprandMakeMTGP32KernelState", CONV_DEVICE_FUNC, API_RAND), - "curand_normal_double": ("hiprand_normal_double", CONV_DEVICE_FUNC, API_RAND), - "curand_normal2": ("hiprand_normal2", CONV_DEVICE_FUNC, API_RAND), - "curand_normal2_double": ("hiprand_normal2_double", CONV_DEVICE_FUNC, API_RAND), - "curand_normal4": ("hiprand_normal4", CONV_DEVICE_FUNC, API_RAND), - "curand_normal4_double": ("hiprand_normal4_double", CONV_DEVICE_FUNC, API_RAND), - "curand_uniform": ("hiprand_uniform", CONV_DEVICE_FUNC, API_RAND), - "curand_uniform_double": ("hiprand_uniform_double", CONV_DEVICE_FUNC, API_RAND), - "curand_uniform2_double": ("hiprand_uniform2_double", CONV_DEVICE_FUNC, API_RAND), - "curand_uniform4": ("hiprand_uniform4", CONV_DEVICE_FUNC, API_RAND), - "curand_uniform4_double": ("hiprand_uniform4_double", CONV_DEVICE_FUNC, API_RAND), - "curand_discrete": ("hiprand_discrete", CONV_DEVICE_FUNC, API_RAND), - "curand_discrete4": ("hiprand_discrete4", CONV_DEVICE_FUNC, API_RAND), - "curand_poisson": ("hiprand_poisson", CONV_DEVICE_FUNC, API_RAND), - "curand_poisson4": ("hiprand_poisson4", CONV_DEVICE_FUNC, API_RAND), - "curand_Philox4x32_10": ("hiprand_Philox4x32_10", CONV_DEVICE_FUNC, API_RAND, HIP_UNSUPPORTED), - "mtgp32_kernel_params": ("mtgp32_kernel_params_t", CONV_MATH_FUNC, API_RAND), - "CUFFT_FORWARD": ("HIPFFT_FORWARD", CONV_NUMERIC_LITERAL, API_BLAS), - "CUFFT_INVERSE": ("HIPFFT_BACKWARD", CONV_NUMERIC_LITERAL, API_BLAS), - "CUFFT_COMPATIBILITY_DEFAULT": ("HIPFFT_COMPATIBILITY_DEFAULT", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED), - "cufftResult_t": ("hipfftResult_t", CONV_TYPE, API_FFT), - "cufftResult": ("hipfftResult", CONV_TYPE, API_FFT), - "CUFFT_SUCCESS": ("HIPFFT_SUCCESS", CONV_NUMERIC_LITERAL, API_FFT), - "CUFFT_INVALID_PLAN": ("HIPFFT_INVALID_PLAN", CONV_NUMERIC_LITERAL, API_FFT), - "CUFFT_ALLOC_FAILED": ("HIPFFT_ALLOC_FAILED", CONV_NUMERIC_LITERAL, API_FFT), - "CUFFT_INVALID_TYPE": ("HIPFFT_INVALID_TYPE", CONV_NUMERIC_LITERAL, API_FFT), - "CUFFT_INVALID_VALUE": ("HIPFFT_INVALID_VALUE", CONV_NUMERIC_LITERAL, API_FFT), - "CUFFT_INTERNAL_ERROR": ("HIPFFT_INTERNAL_ERROR", CONV_NUMERIC_LITERAL, API_FFT), - "CUFFT_EXEC_FAILED": ("HIPFFT_EXEC_FAILED", CONV_NUMERIC_LITERAL, API_FFT), - "CUFFT_SETUP_FAILED": ("HIPFFT_SETUP_FAILED", CONV_NUMERIC_LITERAL, API_FFT), - "CUFFT_INVALID_SIZE": ("HIPFFT_INVALID_SIZE", CONV_NUMERIC_LITERAL, API_FFT), - "CUFFT_UNALIGNED_DATA": ("HIPFFT_UNALIGNED_DATA", CONV_NUMERIC_LITERAL, API_FFT), - "CUFFT_INCOMPLETE_PARAMETER_LIST": ("HIPFFT_INCOMPLETE_PARAMETER_LIST", CONV_NUMERIC_LITERAL, API_FFT), - "CUFFT_INVALID_DEVICE": ("HIPFFT_INVALID_DEVICE", CONV_NUMERIC_LITERAL, API_FFT), - "CUFFT_PARSE_ERROR": ("HIPFFT_PARSE_ERROR", CONV_NUMERIC_LITERAL, API_FFT), - "CUFFT_NO_WORKSPACE": ("HIPFFT_NO_WORKSPACE", CONV_NUMERIC_LITERAL, API_FFT), - "CUFFT_NOT_IMPLEMENTED": ("HIPFFT_NOT_IMPLEMENTED", CONV_NUMERIC_LITERAL, API_FFT), - "CUFFT_LICENSE_ERROR": ("HIPFFT_LICENSE_ERROR", CONV_NUMERIC_LITERAL, API_FFT, HIP_UNSUPPORTED), - "CUFFT_NOT_SUPPORTED": ("HIPFFT_NOT_SUPPORTED", CONV_NUMERIC_LITERAL, API_FFT), - "cufftType_t": ("hipfftType_t", CONV_TYPE, API_FFT), - "cufftType": ("hipfftType", CONV_TYPE, API_FFT), - "CUFFT_R2C": ("HIPFFT_R2C", CONV_NUMERIC_LITERAL, API_FFT), - "CUFFT_C2R": ("HIPFFT_C2R", CONV_NUMERIC_LITERAL, API_FFT), - "CUFFT_C2C": ("HIPFFT_C2C", CONV_NUMERIC_LITERAL, API_FFT), - "CUFFT_D2Z": ("HIPFFT_D2Z", CONV_NUMERIC_LITERAL, API_FFT), - "CUFFT_Z2D": ("HIPFFT_Z2D", CONV_NUMERIC_LITERAL, API_FFT), - "CUFFT_Z2Z": ("HIPFFT_Z2Z", CONV_NUMERIC_LITERAL, API_FFT), - "cufftCompatibility_t": ("hipfftCompatibility_t", CONV_TYPE, API_FFT, HIP_UNSUPPORTED), - "cufftCompatibility": ("hipfftCompatibility", CONV_TYPE, API_FFT, HIP_UNSUPPORTED), - "CUFFT_COMPATIBILITY_FFTW_PADDING": ("HIPFFT_COMPATIBILITY_FFTW_PADDING", CONV_NUMERIC_LITERAL, API_FFT, HIP_UNSUPPORTED), - "cufftReal": ("hipfftReal", CONV_TYPE, API_FFT), - "cufftDoubleReal": ("hipfftDoubleReal", CONV_TYPE, API_FFT), - "cufftComplex": ("hipfftComplex", CONV_TYPE, API_FFT), - "cufftDoubleComplex": ("hipfftDoubleComplex", CONV_TYPE, API_FFT), - "cufftHandle": ("hipfftHandle", CONV_TYPE, API_FFT), - "cufftPlan1d": ("hipfftPlan1d", CONV_MATH_FUNC, API_FFT), - "cufftPlan2d": ("hipfftPlan2d", CONV_MATH_FUNC, API_FFT), - "cufftPlan3d": ("hipfftPlan3d", CONV_MATH_FUNC, API_FFT), - "cufftPlanMany": ("hipfftPlanMany", CONV_MATH_FUNC, API_FFT), - "cufftMakePlan1d": ("hipfftMakePlan1d", CONV_MATH_FUNC, API_FFT), - "cufftMakePlan2d": ("hipfftMakePlan2d", CONV_MATH_FUNC, API_FFT), - "cufftMakePlan3d": ("hipfftMakePlan3d", CONV_MATH_FUNC, API_FFT), - "cufftMakePlanMany": ("hipfftMakePlanMany", CONV_MATH_FUNC, API_FFT), - "cufftMakePlanMany64": ("hipfftMakePlanMany64", CONV_MATH_FUNC, API_FFT), - "cufftGetSizeMany64": ("hipfftGetSizeMany64", CONV_MATH_FUNC, API_FFT), - "cufftEstimate1d": ("hipfftEstimate1d", CONV_MATH_FUNC, API_FFT), - "cufftEstimate2d": ("hipfftEstimate2d", CONV_MATH_FUNC, API_FFT), - "cufftEstimate3d": ("hipfftEstimate3d", CONV_MATH_FUNC, API_FFT), - "cufftEstimateMany": ("hipfftEstimateMany", CONV_MATH_FUNC, API_FFT), - "cufftCreate": ("hipfftCreate", CONV_MATH_FUNC, API_FFT), - "cufftGetSize1d": ("hipfftGetSize1d", CONV_MATH_FUNC, API_FFT), - "cufftGetSize2d": ("hipfftGetSize2d", CONV_MATH_FUNC, API_FFT), - "cufftGetSize3d": ("hipfftGetSize3d", CONV_MATH_FUNC, API_FFT), - "cufftGetSizeMany": ("hipfftGetSizeMany", CONV_MATH_FUNC, API_FFT), - "cufftGetSize": ("hipfftGetSize", CONV_MATH_FUNC, API_FFT), - "cufftSetWorkArea": ("hipfftSetWorkArea", CONV_MATH_FUNC, API_FFT), - "cufftSetAutoAllocation": ("hipfftSetAutoAllocation", CONV_MATH_FUNC, API_FFT), - "cufftExecC2C": ("hipfftExecC2C", CONV_MATH_FUNC, API_FFT), - "cufftExecR2C": ("hipfftExecR2C", CONV_MATH_FUNC, API_FFT), - "cufftExecC2R": ("hipfftExecC2R", CONV_MATH_FUNC, API_FFT), - "cufftExecZ2Z": ("hipfftExecZ2Z", CONV_MATH_FUNC, API_FFT), - "cufftExecD2Z": ("hipfftExecD2Z", CONV_MATH_FUNC, API_FFT), - "cufftExecZ2D": ("hipfftExecZ2D", CONV_MATH_FUNC, API_FFT), - "cufftSetStream": ("hipfftSetStream", CONV_MATH_FUNC, API_FFT), - "cufftDestroy": ("hipfftDestroy", CONV_MATH_FUNC, API_FFT), - "cufftGetVersion": ("hipfftGetVersion", CONV_MATH_FUNC, API_FFT), - "cufftGetProperty": ("hipfftGetProperty", CONV_MATH_FUNC, API_FFT, HIP_UNSUPPORTED), -} +CUDA_IDENTIFIER_MAP = collections.OrderedDict([ + ("__CUDACC__", ("__HIPCC__", CONV_DEF, API_RUNTIME)), + ("CUDA_ERROR_INVALID_CONTEXT", ("hipErrorInvalidContext", CONV_TYPE, API_DRIVER)), + ("CUDA_ERROR_CONTEXT_ALREADY_CURRENT", ("hipErrorContextAlreadyCurrent", CONV_TYPE, API_DRIVER)), + ("CUDA_ERROR_ARRAY_IS_MAPPED", ("hipErrorArrayIsMapped", CONV_TYPE, API_DRIVER)), + ("CUDA_ERROR_ALREADY_MAPPED", ("hipErrorAlreadyMapped", CONV_TYPE, API_DRIVER)), + ("CUDA_ERROR_ALREADY_ACQUIRED", ("hipErrorAlreadyAcquired", CONV_TYPE, API_DRIVER)), + ("CUDA_ERROR_NOT_MAPPED", ("hipErrorNotMapped", CONV_TYPE, API_DRIVER)), + ("CUDA_ERROR_NOT_MAPPED_AS_ARRAY", ("hipErrorNotMappedAsArray", CONV_TYPE, API_DRIVER)), + ("CUDA_ERROR_NOT_MAPPED_AS_POINTER", ("hipErrorNotMappedAsPointer", CONV_TYPE, API_DRIVER)), + ("CUDA_ERROR_CONTEXT_ALREADY_IN_USE", ("hipErrorContextAlreadyInUse", CONV_TYPE, API_DRIVER)), + ("CUDA_ERROR_INVALID_SOURCE", ("hipErrorInvalidSource", CONV_TYPE, API_DRIVER)), + ("CUDA_ERROR_FILE_NOT_FOUND", ("hipErrorFileNotFound", CONV_TYPE, API_DRIVER)), + ("CUDA_ERROR_NOT_FOUND", ("hipErrorNotFound", CONV_TYPE, API_DRIVER)), + ("CUDA_ERROR_LAUNCH_INCOMPATIBLE_TEXTURING", ("hipErrorLaunchIncompatibleTexturing", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUDA_ERROR_PRIMARY_CONTEXT_ACTIVE", ("hipErrorPrimaryContextActive", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUDA_ERROR_CONTEXT_IS_DESTROYED", ("hipErrorContextIsDestroyed", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUDA_ERROR_NOT_PERMITTED", ("hipErrorNotPermitted", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUDA_ERROR_NOT_SUPPORTED", ("hipErrorNotSupported", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("cudaErrorMissingConfiguration", ("hipErrorMissingConfiguration", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorPriorLaunchFailure", ("hipErrorPriorLaunchFailure", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorInvalidDeviceFunction", ("hipErrorInvalidDeviceFunction", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorInvalidConfiguration", ("hipErrorInvalidConfiguration", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorInvalidPitchValue", ("hipErrorInvalidPitchValue", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorInvalidSymbol", ("hipErrorInvalidSymbol", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorInvalidHostPointer", ("hipErrorInvalidHostPointer", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorInvalidDevicePointer", ("hipErrorInvalidDevicePointer", CONV_TYPE, API_RUNTIME)), + ("cudaErrorInvalidTexture", ("hipErrorInvalidTexture", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorInvalidTextureBinding", ("hipErrorInvalidTextureBinding", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorInvalidChannelDescriptor", ("hipErrorInvalidChannelDescriptor", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorInvalidMemcpyDirection", ("hipErrorInvalidMemcpyDirection", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorAddressOfConstant", ("hipErrorAddressOfConstant", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorTextureFetchFailed", ("hipErrorTextureFetchFailed", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorTextureNotBound", ("hipErrorTextureNotBound", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorSynchronizationError", ("hipErrorSynchronizationError", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorInvalidFilterSetting", ("hipErrorInvalidFilterSetting", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorInvalidNormSetting", ("hipErrorInvalidNormSetting", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorMixedDeviceExecution", ("hipErrorMixedDeviceExecution", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorNotYetImplemented", ("hipErrorNotYetImplemented", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorMemoryValueTooLarge", ("hipErrorMemoryValueTooLarge", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorInsufficientDriver", ("hipErrorInsufficientDriver", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorSetOnActiveProcess", ("hipErrorSetOnActiveProcess", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorInvalidSurface", ("hipErrorInvalidSurface", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorDuplicateVariableName", ("hipErrorDuplicateVariableName", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorDuplicateTextureName", ("hipErrorDuplicateTextureName", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorDuplicateSurfaceName", ("hipErrorDuplicateSurfaceName", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorDevicesUnavailable", ("hipErrorDevicesUnavailable", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorIncompatibleDriverContext", ("hipErrorIncompatibleDriverContext", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorDeviceAlreadyInUse", ("hipErrorDeviceAlreadyInUse", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorLaunchMaxDepthExceeded", ("hipErrorLaunchMaxDepthExceeded", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorLaunchFileScopedTex", ("hipErrorLaunchFileScopedTex", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorLaunchFileScopedSurf", ("hipErrorLaunchFileScopedSurf", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorSyncDepthExceeded", ("hipErrorSyncDepthExceeded", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorLaunchPendingCountExceeded", ("hipErrorLaunchPendingCountExceeded", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorNotPermitted", ("hipErrorNotPermitted", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorNotSupported", ("hipErrorNotSupported", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorStartupFailure", ("hipErrorStartupFailure", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaErrorApiFailureBase", ("hipErrorApiFailureBase", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_SUCCESS", ("hipSuccess", CONV_TYPE, API_DRIVER)), + ("cudaSuccess", ("hipSuccess", CONV_TYPE, API_RUNTIME)), + ("CUDA_ERROR_INVALID_VALUE", ("hipErrorInvalidValue", CONV_TYPE, API_DRIVER)), + ("cudaErrorInvalidValue", ("hipErrorInvalidValue", CONV_TYPE, API_RUNTIME)), + ("CUDA_ERROR_OUT_OF_MEMORY", ("hipErrorMemoryAllocation", CONV_TYPE, API_DRIVER)), + ("cudaErrorMemoryAllocation", ("hipErrorMemoryAllocation", CONV_TYPE, API_RUNTIME)), + ("CUDA_ERROR_NOT_INITIALIZED", ("hipErrorNotInitialized", CONV_TYPE, API_DRIVER)), + ("cudaErrorInitializationError", ("hipErrorInitializationError", CONV_TYPE, API_RUNTIME)), + ("CUDA_ERROR_DEINITIALIZED", ("hipErrorDeinitialized", CONV_TYPE, API_DRIVER)), + ("cudaErrorCudartUnloading", ("hipErrorDeinitialized", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_ERROR_PROFILER_DISABLED", ("hipErrorProfilerDisabled", CONV_TYPE, API_DRIVER)), + ("cudaErrorProfilerDisabled", ("hipErrorProfilerDisabled", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_ERROR_PROFILER_NOT_INITIALIZED", ("hipErrorProfilerNotInitialized", CONV_TYPE, API_DRIVER)), + ("cudaErrorProfilerNotInitialized", ("hipErrorProfilerNotInitialized", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_ERROR_PROFILER_ALREADY_STARTED", ("hipErrorProfilerAlreadyStarted", CONV_TYPE, API_DRIVER)), + ("cudaErrorProfilerAlreadyStarted", ("hipErrorProfilerAlreadyStarted", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_ERROR_PROFILER_ALREADY_STOPPED", ("hipErrorProfilerAlreadyStopped", CONV_TYPE, API_DRIVER)), + ("cudaErrorProfilerAlreadyStopped", ("hipErrorProfilerAlreadyStopped", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_ERROR_NO_DEVICE", ("hipErrorNoDevice", CONV_TYPE, API_DRIVER)), + ("cudaErrorNoDevice", ("hipErrorNoDevice", CONV_TYPE, API_RUNTIME)), + ("CUDA_ERROR_INVALID_DEVICE", ("hipErrorInvalidDevice", CONV_TYPE, API_DRIVER)), + ("cudaErrorInvalidDevice", ("hipErrorInvalidDevice", CONV_TYPE, API_RUNTIME)), + ("CUDA_ERROR_INVALID_IMAGE", ("hipErrorInvalidImage", CONV_TYPE, API_DRIVER)), + ("cudaErrorInvalidKernelImage", ("hipErrorInvalidImage", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_ERROR_MAP_FAILED", ("hipErrorMapFailed", CONV_TYPE, API_DRIVER)), + ("cudaErrorMapBufferObjectFailed", ("hipErrorMapFailed", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_ERROR_UNMAP_FAILED", ("hipErrorUnmapFailed", CONV_TYPE, API_DRIVER)), + ("cudaErrorUnmapBufferObjectFailed", ("hipErrorUnmapFailed", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_ERROR_NO_BINARY_FOR_GPU", ("hipErrorNoBinaryForGpu", CONV_TYPE, API_DRIVER)), + ("cudaErrorNoKernelImageForDevice", ("hipErrorNoBinaryForGpu", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_ERROR_ECC_UNCORRECTABLE", ("hipErrorECCNotCorrectable", CONV_TYPE, API_DRIVER)), + ("cudaErrorECCUncorrectable", ("hipErrorECCNotCorrectable", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_ERROR_UNSUPPORTED_LIMIT", ("hipErrorUnsupportedLimit", CONV_TYPE, API_DRIVER)), + ("cudaErrorUnsupportedLimit", ("hipErrorUnsupportedLimit", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_ERROR_PEER_ACCESS_UNSUPPORTED", ("hipErrorPeerAccessUnsupported", CONV_TYPE, API_DRIVER)), + ("cudaErrorPeerAccessUnsupported", ("hipErrorPeerAccessUnsupported", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_ERROR_INVALID_PTX", ("hipErrorInvalidKernelFile", CONV_TYPE, API_DRIVER)), + ("cudaErrorInvalidPtx", ("hipErrorInvalidKernelFile", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_ERROR_INVALID_GRAPHICS_CONTEXT", ("hipErrorInvalidGraphicsContext", CONV_TYPE, API_DRIVER)), + ("cudaErrorInvalidGraphicsContext", ("hipErrorInvalidGraphicsContext", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_ERROR_NVLINK_UNCORRECTABLE", ("hipErrorNvlinkUncorrectable", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("cudaErrorNvlinkUncorrectable", ("hipErrorNvlinkUncorrectable", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_ERROR_SHARED_OBJECT_SYMBOL_NOT_FOUND", ("hipErrorSharedObjectSymbolNotFound", CONV_TYPE, API_DRIVER)), + ("cudaErrorSharedObjectSymbolNotFound", ("hipErrorSharedObjectSymbolNotFound", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_ERROR_SHARED_OBJECT_INIT_FAILED", ("hipErrorSharedObjectInitFailed", CONV_TYPE, API_DRIVER)), + ("cudaErrorSharedObjectInitFailed", ("hipErrorSharedObjectInitFailed", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_ERROR_OPERATING_SYSTEM", ("hipErrorOperatingSystem", CONV_TYPE, API_DRIVER)), + ("cudaErrorOperatingSystem", ("hipErrorOperatingSystem", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_ERROR_INVALID_HANDLE", ("hipErrorInvalidResourceHandle", CONV_TYPE, API_DRIVER)), + ("cudaErrorInvalidResourceHandle", ("hipErrorInvalidResourceHandle", CONV_TYPE, API_RUNTIME)), + ("CUDA_ERROR_NOT_READY", ("hipErrorNotReady", CONV_TYPE, API_DRIVER)), + ("cudaErrorNotReady", ("hipErrorNotReady", CONV_TYPE, API_RUNTIME)), + ("CUDA_ERROR_ILLEGAL_ADDRESS", ("hipErrorIllegalAddress", CONV_TYPE, API_DRIVER)), + ("cudaErrorIllegalAddress", ("hipErrorIllegalAddress", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_ERROR_LAUNCH_OUT_OF_RESOURCES", ("hipErrorLaunchOutOfResources", CONV_TYPE, API_DRIVER)), + ("cudaErrorLaunchOutOfResources", ("hipErrorLaunchOutOfResources", CONV_TYPE, API_RUNTIME)), + ("CUDA_ERROR_LAUNCH_TIMEOUT", ("hipErrorLaunchTimeOut", CONV_TYPE, API_DRIVER)), + ("cudaErrorLaunchTimeout", ("hipErrorLaunchTimeOut", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_ERROR_PEER_ACCESS_ALREADY_ENABLED", ("hipErrorPeerAccessAlreadyEnabled", CONV_TYPE, API_DRIVER)), + ("cudaErrorPeerAccessAlreadyEnabled", ("hipErrorPeerAccessAlreadyEnabled", CONV_TYPE, API_RUNTIME)), + ("CUDA_ERROR_PEER_ACCESS_NOT_ENABLED", ("hipErrorPeerAccessNotEnabled", CONV_TYPE, API_DRIVER)), + ("cudaErrorPeerAccessNotEnabled", ("hipErrorPeerAccessNotEnabled", CONV_TYPE, API_RUNTIME)), + ("CUDA_ERROR_ASSERT", ("hipErrorAssert", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("cudaErrorAssert", ("hipErrorAssert", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_ERROR_TOO_MANY_PEERS", ("hipErrorTooManyPeers", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("cudaErrorTooManyPeers", ("hipErrorTooManyPeers", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_ERROR_HOST_MEMORY_ALREADY_REGISTERED", ("hipErrorHostMemoryAlreadyRegistered", CONV_TYPE, API_DRIVER)), + ("cudaErrorHostMemoryAlreadyRegistered", ("hipErrorHostMemoryAlreadyRegistered", CONV_TYPE, API_RUNTIME)), + ("CUDA_ERROR_HOST_MEMORY_NOT_REGISTERED", ("hipErrorHostMemoryNotRegistered", CONV_TYPE, API_DRIVER)), + ("cudaErrorHostMemoryNotRegistered", ("hipErrorHostMemoryNotRegistered", CONV_TYPE, API_RUNTIME)), + ("CUDA_ERROR_HARDWARE_STACK_ERROR", ("hipErrorHardwareStackError", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("cudaErrorHardwareStackError", ("hipErrorHardwareStackError", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_ERROR_ILLEGAL_INSTRUCTION", ("hipErrorIllegalInstruction", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("cudaErrorIllegalInstruction", ("hipErrorIllegalInstruction", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_ERROR_MISALIGNED_ADDRESS", ("hipErrorMisalignedAddress", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("cudaErrorMisalignedAddress", ("hipErrorMisalignedAddress", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_ERROR_INVALID_ADDRESS_SPACE", ("hipErrorInvalidAddressSpace", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("cudaErrorInvalidAddressSpace", ("hipErrorInvalidAddressSpace", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_ERROR_INVALID_PC", ("hipErrorInvalidPc", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("cudaErrorInvalidPc", ("hipErrorInvalidPc", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_ERROR_LAUNCH_FAILED", ("hipErrorLaunchFailure", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("cudaErrorLaunchFailure", ("hipErrorLaunchFailure", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_ERROR_UNKNOWN", ("hipErrorUnknown", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("cudaErrorUnknown", ("hipErrorUnknown", CONV_TYPE, API_RUNTIME)), + ("CU_TR_ADDRESS_MODE_WRAP", ("HIP_TR_ADDRESS_MODE_WRAP", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_TR_ADDRESS_MODE_CLAMP", ("HIP_TR_ADDRESS_MODE_CLAMP", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_TR_ADDRESS_MODE_MIRROR", ("HIP_TR_ADDRESS_MODE_MIRROR", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_TR_ADDRESS_MODE_BORDER", ("HIP_TR_ADDRESS_MODE_BORDER", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_CUBEMAP_FACE_POSITIVE_X", ("HIP_CUBEMAP_FACE_POSITIVE_X", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_CUBEMAP_FACE_NEGATIVE_X", ("HIP_CUBEMAP_FACE_NEGATIVE_X", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_CUBEMAP_FACE_POSITIVE_Y", ("HIP_CUBEMAP_FACE_POSITIVE_Y", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_CUBEMAP_FACE_NEGATIVE_Y", ("HIP_CUBEMAP_FACE_NEGATIVE_Y", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_CUBEMAP_FACE_POSITIVE_Z", ("HIP_CUBEMAP_FACE_POSITIVE_Z", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_CUBEMAP_FACE_NEGATIVE_Z", ("HIP_CUBEMAP_FACE_NEGATIVE_Z", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_AD_FORMAT_UNSIGNED_INT8", ("HIP_AD_FORMAT_UNSIGNED_INT8", CONV_TYPE, API_DRIVER)), + ("CU_AD_FORMAT_UNSIGNED_INT16", ("HIP_AD_FORMAT_UNSIGNED_INT16", CONV_TYPE, API_DRIVER)), + ("CU_AD_FORMAT_UNSIGNED_INT32", ("HIP_AD_FORMAT_UNSIGNED_INT32", CONV_TYPE, API_DRIVER)), + ("CU_AD_FORMAT_SIGNED_INT8", ("HIP_AD_FORMAT_SIGNED_INT8", CONV_TYPE, API_DRIVER)), + ("CU_AD_FORMAT_SIGNED_INT16", ("HIP_AD_FORMAT_SIGNED_INT16", CONV_TYPE, API_DRIVER)), + ("CU_AD_FORMAT_SIGNED_INT32", ("HIP_AD_FORMAT_SIGNED_INT32", CONV_TYPE, API_DRIVER)), + ("CU_AD_FORMAT_HALF", ("HIP_AD_FORMAT_HALF", CONV_TYPE, API_DRIVER)), + ("CU_AD_FORMAT_FLOAT", ("HIP_AD_FORMAT_FLOAT", CONV_TYPE, API_DRIVER)), + ("CU_COMPUTEMODE_DEFAULT", ("hipComputeModeDefault", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_COMPUTEMODE_EXCLUSIVE", ("hipComputeModeExclusive", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_COMPUTEMODE_PROHIBITED", ("hipComputeModeProhibited", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_COMPUTEMODE_EXCLUSIVE_PROCESS", ("hipComputeModeExclusiveProcess", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_MEM_ADVISE_SET_READ_MOSTLY", ("hipMemAdviseSetReadMostly", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_MEM_ADVISE_UNSET_READ_MOSTLY", ("hipMemAdviseUnsetReadMostly", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_MEM_ADVISE_SET_PREFERRED_LOCATION", ("hipMemAdviseSetPreferredLocation", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_MEM_ADVISE_UNSET_PREFERRED_LOCATION", ("hipMemAdviseUnsetPreferredLocation", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_MEM_ADVISE_SET_ACCESSED_BY", ("hipMemAdviseSetAccessedBy", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_MEM_ADVISE_UNSET_ACCESSED_BY", ("hipMemAdviseUnsetAccessedBy", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_MEM_RANGE_ATTRIBUTE_READ_MOSTLY", ("hipMemRangeAttributeReadMostly", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_MEM_RANGE_ATTRIBUTE_PREFERRED_LOCATION", ("hipMemRangeAttributePreferredLocation", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_MEM_RANGE_ATTRIBUTE_ACCESSED_BY", ("hipMemRangeAttributeAccessedBy", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_MEM_RANGE_ATTRIBUTE_LAST_PREFETCH_LOCATION", ("hipMemRangeAttributeLastPrefetchLocation", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_CTX_SCHED_AUTO", ("HIP_CTX_SCHED_AUTO", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_CTX_SCHED_SPIN", ("HIP_CTX_SCHED_SPIN", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_CTX_SCHED_YIELD", ("HIP_CTX_SCHED_YIELD", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_CTX_SCHED_BLOCKING_SYNC", ("HIP_CTX_SCHED_BLOCKING_SYNC", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_CTX_BLOCKING_SYNC", ("HIP_CTX_BLOCKING_SYNC", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_CTX_SCHED_MASK", ("HIP_CTX_SCHED_MASK", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_CTX_MAP_HOST", ("HIP_CTX_MAP_HOST", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_CTX_LMEM_RESIZE_TO_MAX", ("HIP_CTX_LMEM_RESIZE_TO_MAX", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_CTX_FLAGS_MASK", ("HIP_CTX_FLAGS_MASK", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_LAUNCH_PARAM_BUFFER_POINTER", ("HIP_LAUNCH_PARAM_BUFFER_POINTER", CONV_TYPE, API_DRIVER)), + ("CU_LAUNCH_PARAM_BUFFER_SIZE", ("HIP_LAUNCH_PARAM_BUFFER_SIZE", CONV_TYPE, API_DRIVER)), + ("CU_LAUNCH_PARAM_END", ("HIP_LAUNCH_PARAM_END", CONV_TYPE, API_DRIVER)), + ("CU_IPC_HANDLE_SIZE", ("HIP_LAUNCH_PARAM_END", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_MEMHOSTALLOC_DEVICEMAP", ("HIP_MEMHOSTALLOC_DEVICEMAP", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_MEMHOSTALLOC_PORTABLE", ("HIP_MEMHOSTALLOC_PORTABLE", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_MEMHOSTALLOC_WRITECOMBINED", ("HIP_MEMHOSTALLOC_WRITECOMBINED", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_MEMHOSTREGISTER_DEVICEMAP", ("HIP_MEMHOSTREGISTER_DEVICEMAP", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_MEMHOSTREGISTER_IOMEMORY", ("HIP_MEMHOSTREGISTER_IOMEMORY", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_MEMHOSTREGISTER_PORTABLE", ("HIP_MEMHOSTREGISTER_PORTABLE", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_PARAM_TR_DEFAULT", ("HIP_PARAM_TR_DEFAULT", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_STREAM_LEGACY", ("HIP_STREAM_LEGACY", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_STREAM_PER_THREAD", ("HIP_STREAM_PER_THREAD", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_TRSA_OVERRIDE_FORMAT", ("HIP_TRSA_OVERRIDE_FORMAT", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_TRSF_NORMALIZED_COORDINATES", ("HIP_TRSF_NORMALIZED_COORDINATES", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_TRSF_READ_AS_INTEGER", ("HIP_TRSF_READ_AS_INTEGER", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_TRSF_SRGB", ("HIP_TRSF_SRGB", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUDA_ARRAY3D_2DARRAY", ("HIP_ARRAY3D_LAYERED", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUDA_ARRAY3D_CUBEMAP", ("HIP_ARRAY3D_CUBEMAP", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUDA_ARRAY3D_DEPTH_TEXTURE", ("HIP_ARRAY3D_DEPTH_TEXTURE", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUDA_ARRAY3D_LAYERED", ("HIP_ARRAY3D_LAYERED", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUDA_ARRAY3D_SURFACE_LDST", ("HIP_ARRAY3D_SURFACE_LDST", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUDA_ARRAY3D_TEXTURE_GATHER", ("HIP_ARRAY3D_TEXTURE_GATHER", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + # ("CUDA_VERSION", ("HIP_VERSION", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_BLOCK", ("hipDeviceAttributeMaxThreadsPerBlock", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_X", ("hipDeviceAttributeMaxBlockDimX", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Y", ("hipDeviceAttributeMaxBlockDimY", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAX_BLOCK_DIM_Z", ("hipDeviceAttributeMaxBlockDimZ", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_X", ("hipDeviceAttributeMaxGridDimX", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Y", ("hipDeviceAttributeMaxGridDimY", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAX_GRID_DIM_Z", ("hipDeviceAttributeMaxGridDimZ", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_BLOCK", ("hipDeviceAttributeMaxSharedMemoryPerBlock", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_SHARED_MEMORY_PER_BLOCK", ("hipDeviceAttributeMaxSharedMemoryPerBlock", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_TOTAL_CONSTANT_MEMORY", ("hipDeviceAttributeTotalConstantMemory", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_WARP_SIZE", ("hipDeviceAttributeWarpSize", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAX_PITCH", ("hipDeviceAttributeMaxPitch", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_BLOCK", ("hipDeviceAttributeMaxRegistersPerBlock", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_REGISTERS_PER_BLOCK", ("hipDeviceAttributeMaxRegistersPerBlock", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_CLOCK_RATE", ("hipDeviceAttributeClockRate", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_TEXTURE_ALIGNMENT", ("hipDeviceAttributeTextureAlignment", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_GPU_OVERLAP", ("hipDeviceAttributeAsyncEngineCount", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT", ("hipDeviceAttributeMultiprocessorCount", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_KERNEL_EXEC_TIMEOUT", ("hipDeviceAttributeKernelExecTimeout", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_INTEGRATED", ("hipDeviceAttributeIntegrated", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_CAN_MAP_HOST_MEMORY", ("hipDeviceAttributeCanMapHostMemory", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_COMPUTE_MODE", ("hipDeviceAttributeComputeMode", CONV_TYPE, API_DRIVER)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_WIDTH", ("hipDeviceAttributeMaxTexture1DWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_WIDTH", ("hipDeviceAttributeMaxTexture2DWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_HEIGHT", ("hipDeviceAttributeMaxTexture2DHeight", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH", ("hipDeviceAttributeMaxTexture3DWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT", ("hipDeviceAttributeMaxTexture3DHeight", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH", ("hipDeviceAttributeMaxTexture3DDepth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_WIDTH", ("hipDeviceAttributeMaxTexture2DLayeredWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_HEIGHT", ("hipDeviceAttributeMaxTexture2DLayeredHeight", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LAYERED_LAYERS", ("hipDeviceAttributeMaxTexture2DLayeredLayers", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_WIDTH", ("hipDeviceAttributeMaxTexture2DLayeredWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_HEIGHT", ("hipDeviceAttributeMaxTexture2DLayeredHeight", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_ARRAY_NUMSLICES", ("hipDeviceAttributeMaxTexture2DLayeredLayers", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_SURFACE_ALIGNMENT", ("hipDeviceAttributeSurfaceAlignment", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_CONCURRENT_KERNELS", ("hipDeviceAttributeConcurrentKernels", CONV_TYPE, API_DRIVER)), + ("CU_DEVICE_ATTRIBUTE_ECC_ENABLED", ("hipDeviceAttributeEccEnabled", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_PCI_BUS_ID", ("hipDeviceAttributePciBusId", CONV_TYPE, API_DRIVER)), + ("CU_DEVICE_ATTRIBUTE_PCI_DEVICE_ID", ("hipDeviceAttributePciDeviceId", CONV_TYPE, API_DRIVER)), + ("CU_DEVICE_ATTRIBUTE_TCC_DRIVER", ("hipDeviceAttributeTccDriver", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MEMORY_CLOCK_RATE", ("hipDeviceAttributeMemoryClockRate", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_GLOBAL_MEMORY_BUS_WIDTH", ("hipDeviceAttributeMemoryBusWidth", CONV_TYPE, API_DRIVER)), + ("CU_DEVICE_ATTRIBUTE_L2_CACHE_SIZE", ("hipDeviceAttributeL2CacheSize", CONV_TYPE, API_DRIVER)), + ("CU_DEVICE_ATTRIBUTE_MAX_THREADS_PER_MULTIPROCESSOR", ("hipDeviceAttributeMaxThreadsPerMultiProcessor", CONV_TYPE, API_DRIVER)), + ("CU_DEVICE_ATTRIBUTE_ASYNC_ENGINE_COUNT", ("hipDeviceAttributeAsyncEngineCount", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_UNIFIED_ADDRESSING", ("hipDeviceAttributeUnifiedAddressing", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_WIDTH", ("hipDeviceAttributeMaxTexture1DLayeredWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LAYERED_LAYERS", ("hipDeviceAttributeMaxTexture1DLayeredLayers", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_CAN_TEX2D_GATHER", ("hipDeviceAttributeCanTex2DGather", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_WIDTH", ("hipDeviceAttributeMaxTexture2DGatherWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_GATHER_HEIGHT", ("hipDeviceAttributeMaxTexture2DGatherHeight", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_WIDTH_ALTERNATE", ("hipDeviceAttributeMaxTexture3DWidthAlternate", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_HEIGHT_ALTERNATE", ("hipDeviceAttributeMaxTexture3DHeightAlternate", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE3D_DEPTH_ALTERNATE", ("hipDeviceAttributeMaxTexture3DDepthAlternate", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_PCI_DOMAIN_ID", ("hipDeviceAttributePciDomainId", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_TEXTURE_PITCH_ALIGNMENT", ("hipDeviceAttributeTexturePitchAlignment", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_WIDTH", ("hipDeviceAttributeMaxTextureCubemapWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_WIDTH", ("hipDeviceAttributeMaxTextureCubemapLayeredWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURECUBEMAP_LAYERED_LAYERS", ("hipDeviceAttributeMaxTextureCubemapLayeredLayers", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_WIDTH", ("hipDeviceAttributeMaxSurface1DWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_WIDTH", ("hipDeviceAttributeMaxSurface2DWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_HEIGHT", ("hipDeviceAttributeMaxSurface2DHeight", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_WIDTH", ("hipDeviceAttributeMaxSurface3DWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_HEIGHT", ("hipDeviceAttributeMaxSurface3DHeight", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE3D_DEPTH", ("hipDeviceAttributeMaxSurface3DDepth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_WIDTH", ("hipDeviceAttributeMaxSurface1DLayeredWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE1D_LAYERED_LAYERS", ("hipDeviceAttributeMaxSurface1DLayeredLayers", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_WIDTH", ("hipDeviceAttributeMaxSurface2DLayeredWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_HEIGHT", ("hipDeviceAttributeMaxSurface2DLayeredHeight", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACE2D_LAYERED_LAYERS", ("hipDeviceAttributeMaxSurface2DLayeredLayers", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_WIDTH", ("hipDeviceAttributeMaxSurfaceCubemapWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_WIDTH", ("hipDeviceAttributeMaxSurfaceCubemapLayeredWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_SURFACECUBEMAP_LAYERED_LAYERS", ("hipDeviceAttributeMaxSurfaceCubemapLayeredLayers", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_LINEAR_WIDTH", ("hipDeviceAttributeMaxTexture1DLinearWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_WIDTH", ("hipDeviceAttributeMaxTexture2DLinearWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_HEIGHT", ("hipDeviceAttributeMaxTexture2DLinearHeight", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_LINEAR_PITCH", ("hipDeviceAttributeMaxTexture2DLinearPitch", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_WIDTH", ("hipDeviceAttributeMaxTexture2DMipmappedWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE2D_MIPMAPPED_HEIGHT", ("hipDeviceAttributeMaxTexture2DMipmappedHeight", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MAJOR", ("hipDeviceAttributeComputeCapabilityMajor", CONV_TYPE, API_DRIVER)), + ("CU_DEVICE_ATTRIBUTE_COMPUTE_CAPABILITY_MINOR", ("hipDeviceAttributeComputeCapabilityMinor", CONV_TYPE, API_DRIVER)), + ("CU_DEVICE_ATTRIBUTE_MAXIMUM_TEXTURE1D_MIPMAPPED_WIDTH", ("hipDeviceAttributeMaxTexture1DMipmappedWidth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_STREAM_PRIORITIES_SUPPORTED", ("hipDeviceAttributeStreamPrioritiesSupported", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_GLOBAL_L1_CACHE_SUPPORTED", ("hipDeviceAttributeGlobalL1CacheSupported", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_LOCAL_L1_CACHE_SUPPORTED", ("hipDeviceAttributeLocalL1CacheSupported", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAX_SHARED_MEMORY_PER_MULTIPROCESSOR", ("hipDeviceAttributeMaxSharedMemoryPerMultiprocessor", CONV_TYPE, API_DRIVER)), + ("CU_DEVICE_ATTRIBUTE_MAX_REGISTERS_PER_MULTIPROCESSOR", ("hipDeviceAttributeMaxRegistersPerMultiprocessor", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MANAGED_MEMORY", ("hipDeviceAttributeManagedMemory", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD", ("hipDeviceAttributeIsMultiGpuBoard", CONV_TYPE, API_DRIVER)), + ("CU_DEVICE_ATTRIBUTE_MULTI_GPU_BOARD_GROUP_ID", ("hipDeviceAttributeMultiGpuBoardGroupId", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_HOST_NATIVE_ATOMIC_SUPPORTED", ("hipDeviceAttributeHostNativeAtomicSupported", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_SINGLE_TO_DOUBLE_PRECISION_PERF_RATIO", ("hipDeviceAttributeSingleToDoublePrecisionPerfRatio", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_PAGEABLE_MEMORY_ACCESS", ("hipDeviceAttributePageableMemoryAccess", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_CONCURRENT_MANAGED_ACCESS", ("hipDeviceAttributeConcurrentManagedAccess", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_COMPUTE_PREEMPTION_SUPPORTED", ("hipDeviceAttributeComputePreemptionSupported", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_CAN_USE_HOST_POINTER_FOR_REGISTERED_MEM", ("hipDeviceAttributeCanUseHostPointerForRegisteredMem", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_ATTRIBUTE_MAX", ("hipDeviceAttributeMax", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_POINTER_ATTRIBUTE_CONTEXT", ("hipPointerAttributeContext", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_POINTER_ATTRIBUTE_MEMORY_TYPE", ("hipPointerAttributeMemoryType", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_POINTER_ATTRIBUTE_DEVICE_POINTER", ("hipPointerAttributeDevicePointer", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_POINTER_ATTRIBUTE_HOST_POINTER", ("hipPointerAttributeHostPointer", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_POINTER_ATTRIBUTE_P2P_TOKENS", ("hipPointerAttributeP2pTokens", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_POINTER_ATTRIBUTE_SYNC_MEMOPS", ("hipPointerAttributeSyncMemops", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_POINTER_ATTRIBUTE_BUFFER_ID", ("hipPointerAttributeBufferId", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_POINTER_ATTRIBUTE_IS_MANAGED", ("hipPointerAttributeIsManaged", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_FUNC_ATTRIBUTE_MAX_THREADS_PER_BLOCK", ("hipFuncAttributeMaxThreadsPerBlocks", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_FUNC_ATTRIBUTE_SHARED_SIZE_BYTES", ("hipFuncAttributeSharedSizeBytes", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_FUNC_ATTRIBUTE_CONST_SIZE_BYTES", ("hipFuncAttributeConstSizeBytes", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_FUNC_ATTRIBUTE_LOCAL_SIZE_BYTES", ("hipFuncAttributeLocalSizeBytes", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_FUNC_ATTRIBUTE_NUM_REGS", ("hipFuncAttributeNumRegs", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_FUNC_ATTRIBUTE_PTX_VERSION", ("hipFuncAttributePtxVersion", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_FUNC_ATTRIBUTE_BINARY_VERSION", ("hipFuncAttributeBinaryVersion", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_FUNC_ATTRIBUTE_CACHE_MODE_CA", ("hipFuncAttributeCacheModeCA", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_FUNC_ATTRIBUTE_MAX", ("hipFuncAttributeMax", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_GRAPHICS_MAP_RESOURCE_FLAGS_NONE", ("hipGraphicsMapFlagsNone", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_GRAPHICS_MAP_RESOURCE_FLAGS_READ_ONLY", ("hipGraphicsMapFlagsReadOnly", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_GRAPHICS_MAP_RESOURCE_FLAGS_WRITE_DISCARD", ("hipGraphicsMapFlagsWriteDiscard", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_GRAPHICS_REGISTER_FLAGS_NONE", ("hipGraphicsRegisterFlagsNone", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_GRAPHICS_REGISTER_FLAGS_READ_ONLY", ("hipGraphicsRegisterFlagsReadOnly", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_GRAPHICS_REGISTER_FLAGS_WRITE_DISCARD", ("hipGraphicsRegisterFlagsWriteDiscard", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_GRAPHICS_REGISTER_FLAGS_SURFACE_LDST", ("hipGraphicsRegisterFlagsSurfaceLoadStore", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_GRAPHICS_REGISTER_FLAGS_TEXTURE_GATHER", ("hipGraphicsRegisterFlagsTextureGather", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_OCCUPANCY_DEFAULT", ("hipOccupancyDefault", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_OCCUPANCY_DISABLE_CACHING_OVERRIDE", ("hipOccupancyDisableCachingOverride", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_FUNC_CACHE_PREFER_NONE", ("hipFuncCachePreferNone", CONV_CACHE, API_DRIVER)), + ("CU_FUNC_CACHE_PREFER_SHARED", ("hipFuncCachePreferShared", CONV_CACHE, API_DRIVER)), + ("CU_FUNC_CACHE_PREFER_L1", ("hipFuncCachePreferL1", CONV_CACHE, API_DRIVER)), + ("CU_FUNC_CACHE_PREFER_EQUAL", ("hipFuncCachePreferEqual", CONV_CACHE, API_DRIVER)), + ("CU_IPC_MEM_LAZY_ENABLE_PEER_ACCESS", ("hipIpcMemLazyEnablePeerAccess", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CUDA_IPC_HANDLE_SIZE", ("HIP_IPC_HANDLE_SIZE", CONV_TYPE, API_DRIVER)), + ("CU_JIT_CACHE_OPTION_NONE", ("hipJitCacheModeOptionNone", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_JIT_CACHE_OPTION_CG", ("hipJitCacheModeOptionCG", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_JIT_CACHE_OPTION_CA", ("hipJitCacheModeOptionCA", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_PREFER_PTX", ("hipJitFallbackPreferPtx", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_PREFER_BINARY", ("hipJitFallbackPreferBinary", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_JIT_MAX_REGISTERS", ("hipJitOptionMaxRegisters", CONV_JIT, API_DRIVER)), + ("CU_JIT_THREADS_PER_BLOCK", ("hipJitOptionThreadsPerBlock", CONV_JIT, API_DRIVER)), + ("CU_JIT_WALL_TIME", ("hipJitOptionWallTime", CONV_JIT, API_DRIVER)), + ("CU_JIT_INFO_LOG_BUFFER", ("hipJitOptionInfoLogBuffer", CONV_JIT, API_DRIVER)), + ("CU_JIT_INFO_LOG_BUFFER_SIZE_BYTES", ("hipJitOptionInfoLogBufferSizeBytes", CONV_JIT, API_DRIVER)), + ("CU_JIT_ERROR_LOG_BUFFER", ("hipJitOptionErrorLogBuffer", CONV_JIT, API_DRIVER)), + ("CU_JIT_ERROR_LOG_BUFFER_SIZE_BYTES", ("hipJitOptionErrorLogBufferSizeBytes", CONV_JIT, API_DRIVER)), + ("CU_JIT_OPTIMIZATION_LEVEL", ("hipJitOptionOptimizationLevel", CONV_JIT, API_DRIVER)), + ("CU_JIT_TARGET_FROM_CUCONTEXT", ("hipJitOptionTargetFromContext", CONV_JIT, API_DRIVER)), + ("CU_JIT_TARGET", ("hipJitOptionTarget", CONV_JIT, API_DRIVER)), + ("CU_JIT_FALLBACK_STRATEGY", ("hipJitOptionFallbackStrategy", CONV_JIT, API_DRIVER)), + ("CU_JIT_GENERATE_DEBUG_INFO", ("hipJitOptionGenerateDebugInfo", CONV_JIT, API_DRIVER)), + ("CU_JIT_LOG_VERBOSE", ("hipJitOptionLogVerbose", CONV_JIT, API_DRIVER)), + ("CU_JIT_GENERATE_LINE_INFO", ("hipJitOptionGenerateLineInfo", CONV_JIT, API_DRIVER)), + ("CU_JIT_CACHE_MODE", ("hipJitOptionCacheMode", CONV_JIT, API_DRIVER)), + ("CU_JIT_NEW_SM3X_OPT", ("hipJitOptionSm3xOpt", CONV_JIT, API_DRIVER)), + ("CU_JIT_FAST_COMPILE", ("hipJitOptionFastCompile", CONV_JIT, API_DRIVER)), + ("CU_JIT_NUM_OPTIONS", ("hipJitOptionNumOptions", CONV_JIT, API_DRIVER)), + ("CU_TARGET_COMPUTE_10", ("hipJitTargetCompute10", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_TARGET_COMPUTE_11", ("hipJitTargetCompute11", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_TARGET_COMPUTE_12", ("hipJitTargetCompute12", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_TARGET_COMPUTE_13", ("hipJitTargetCompute13", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_TARGET_COMPUTE_20", ("hipJitTargetCompute20", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_TARGET_COMPUTE_21", ("hipJitTargetCompute21", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_TARGET_COMPUTE_30", ("hipJitTargetCompute30", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_TARGET_COMPUTE_32", ("hipJitTargetCompute32", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_TARGET_COMPUTE_35", ("hipJitTargetCompute35", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_TARGET_COMPUTE_37", ("hipJitTargetCompute37", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_TARGET_COMPUTE_50", ("hipJitTargetCompute50", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_TARGET_COMPUTE_52", ("hipJitTargetCompute52", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_TARGET_COMPUTE_53", ("hipJitTargetCompute53", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_TARGET_COMPUTE_60", ("hipJitTargetCompute60", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_TARGET_COMPUTE_61", ("hipJitTargetCompute61", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_TARGET_COMPUTE_62", ("hipJitTargetCompute62", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_JIT_INPUT_CUBIN", ("hipJitInputTypeBin", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_JIT_INPUT_PTX", ("hipJitInputTypePtx", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_JIT_INPUT_FATBINARY", ("hipJitInputTypeFatBinary", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_JIT_INPUT_OBJECT", ("hipJitInputTypeObject", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_JIT_INPUT_LIBRARY", ("hipJitInputTypeLibrary", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_JIT_NUM_INPUT_TYPES", ("hipJitInputTypeNumInputTypes", CONV_JIT, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_LIMIT_STACK_SIZE", ("hipLimitStackSize", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_LIMIT_PRINTF_FIFO_SIZE", ("hipLimitPrintfFifoSize", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_LIMIT_MALLOC_HEAP_SIZE", ("hipLimitMallocHeapSize", CONV_TYPE, API_DRIVER)), + ("CU_LIMIT_DEV_RUNTIME_SYNC_DEPTH", ("hipLimitDevRuntimeSyncDepth", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_LIMIT_DEV_RUNTIME_PENDING_LAUNCH_COUNT", ("hipLimitDevRuntimePendingLaunchCount", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_LIMIT_STACK_SIZE", ("hipLimitStackSize", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_MEM_ATTACH_GLOBAL", ("hipMemAttachGlobal", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_MEM_ATTACH_HOST", ("hipMemAttachHost", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_MEM_ATTACH_SINGLE", ("hipMemAttachSingle", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_MEMORYTYPE_HOST", ("hipMemTypeHost", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_MEMORYTYPE_DEVICE", ("hipMemTypeDevice", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_MEMORYTYPE_ARRAY", ("hipMemTypeArray", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_MEMORYTYPE_UNIFIED", ("hipMemTypeUnified", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_RESOURCE_TYPE_ARRAY", ("hipResourceTypeArray", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_RESOURCE_TYPE_MIPMAPPED_ARRAY", ("hipResourceTypeMipmappedArray", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_RESOURCE_TYPE_LINEAR", ("hipResourceTypeLinear", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_RESOURCE_TYPE_PITCH2D", ("hipResourceTypePitch2D", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_RES_VIEW_FORMAT_NONE", ("hipResViewFormatNone", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_UINT_1X8", ("hipResViewFormatUnsignedChar1", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_UINT_2X8", ("hipResViewFormatUnsignedChar2", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_UINT_4X8", ("hipResViewFormatUnsignedChar4", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_SINT_1X8", ("hipResViewFormatSignedChar1", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_SINT_2X8", ("hipResViewFormatSignedChar2", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_SINT_4X8", ("hipResViewFormatSignedChar4", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_UINT_1X16", ("hipResViewFormatUnsignedShort1", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_UINT_2X16", ("hipResViewFormatUnsignedShort2", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_UINT_4X16", ("hipResViewFormatUnsignedShort4", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_SINT_1X16", ("hipResViewFormatSignedShort1", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_SINT_2X16", ("hipResViewFormatSignedShort2", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_SINT_4X16", ("hipResViewFormatSignedShort4", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_UINT_1X32", ("hipResViewFormatUnsignedInt1", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_UINT_2X32", ("hipResViewFormatUnsignedInt2", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_UINT_4X32", ("hipResViewFormatUnsignedInt4", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_SINT_1X32", ("hipResViewFormatSignedInt1", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_SINT_2X32", ("hipResViewFormatSignedInt2", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_SINT_4X32", ("hipResViewFormatSignedInt4", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_FLOAT_1X16", ("hipResViewFormatHalf1", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_FLOAT_2X16", ("hipResViewFormatHalf2", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_FLOAT_4X16", ("hipResViewFormatHalf4", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_FLOAT_1X32", ("hipResViewFormatFloat1", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_FLOAT_2X32", ("hipResViewFormatFloat2", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_FLOAT_4X32", ("hipResViewFormatFloat4", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_UNSIGNED_BC1", ("hipResViewFormatUnsignedBlockCompressed1", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_UNSIGNED_BC2", ("hipResViewFormatUnsignedBlockCompressed2", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_UNSIGNED_BC3", ("hipResViewFormatUnsignedBlockCompressed3", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_UNSIGNED_BC4", ("hipResViewFormatUnsignedBlockCompressed4", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_SIGNED_BC4", ("hipResViewFormatSignedBlockCompressed4", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_UNSIGNED_BC5", ("hipResViewFormatUnsignedBlockCompressed5", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_SIGNED_BC5", ("hipResViewFormatSignedBlockCompressed5", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_UNSIGNED_BC6H", ("hipResViewFormatUnsignedBlockCompressed6H", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_SIGNED_BC6H", ("hipResViewFormatSignedBlockCompressed6H", CONV_TEX, API_DRIVER)), + ("CU_RES_VIEW_FORMAT_UNSIGNED_BC7", ("hipResViewFormatUnsignedBlockCompressed7", CONV_TEX, API_DRIVER)), + ("CU_SHARED_MEM_CONFIG_DEFAULT_BANK_SIZE", ("hipSharedMemBankSizeDefault", CONV_TYPE, API_DRIVER)), + ("CU_SHARED_MEM_CONFIG_FOUR_BYTE_BANK_SIZE", ("hipSharedMemBankSizeFourByte", CONV_TYPE, API_DRIVER)), + ("CU_SHARED_MEM_CONFIG_EIGHT_BYTE_BANK_SIZE", ("hipSharedMemBankSizeEightByte", CONV_TYPE, API_DRIVER)), + ("CU_STREAM_DEFAULT", ("hipStreamDefault", CONV_TYPE, API_DRIVER)), + ("CU_STREAM_NON_BLOCKING", ("hipStreamNonBlocking", CONV_TYPE, API_DRIVER)), + ("CU_STREAM_WAIT_VALUE_GEQ", ("hipStreamWaitValueGeq", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_STREAM_WAIT_VALUE_EQ", ("hipStreamWaitValueEq", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_STREAM_WAIT_VALUE_AND", ("hipStreamWaitValueAnd", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_STREAM_WAIT_VALUE_FLUSH", ("hipStreamWaitValueFlush", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_STREAM_WRITE_VALUE_DEFAULT", ("hipStreamWriteValueDefault", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_STREAM_WRITE_VALUE_NO_MEMORY_BARRIER", ("hipStreamWriteValueNoMemoryBarrier", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_STREAM_MEM_OP_WAIT_VALUE_32", ("hipStreamBatchMemOpWaitValue32", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_STREAM_MEM_OP_WRITE_VALUE_32", ("hipStreamBatchMemOpWriteValue32", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_STREAM_MEM_OP_FLUSH_REMOTE_WRITES", ("hipStreamBatchMemOpFlushRemoteWrites", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("cuGetErrorName", ("hipGetErrorName___", CONV_ERROR, API_DRIVER, HIP_UNSUPPORTED)), + ("cuGetErrorString", ("hipGetErrorString___", CONV_ERROR, API_DRIVER, HIP_UNSUPPORTED)), + ("cuInit", ("hipInit", CONV_INIT, API_DRIVER)), + ("cuDriverGetVersion", ("hipDriverGetVersion", CONV_VERSION, API_DRIVER)), + ("cuCtxCreate_v2", ("hipCtxCreate", CONV_CONTEXT, API_DRIVER)), + ("cuCtxDestroy_v2", ("hipCtxDestroy", CONV_CONTEXT, API_DRIVER)), + ("cuCtxGetApiVersion", ("hipCtxGetApiVersion", CONV_CONTEXT, API_DRIVER)), + ("cuCtxGetCacheConfig", ("hipCtxGetCacheConfig", CONV_CONTEXT, API_DRIVER)), + ("cuCtxGetCurrent", ("hipCtxGetCurrent", CONV_CONTEXT, API_DRIVER)), + ("cuCtxGetDevice", ("hipCtxGetDevice", CONV_CONTEXT, API_DRIVER)), + ("cuCtxGetFlags", ("hipCtxGetFlags", CONV_CONTEXT, API_DRIVER)), + ("cuCtxGetLimit", ("hipCtxGetLimit", CONV_CONTEXT, API_DRIVER, HIP_UNSUPPORTED)), + ("cuCtxGetSharedMemConfig", ("hipCtxGetSharedMemConfig", CONV_CONTEXT, API_DRIVER)), + ("cuCtxGetStreamPriorityRange", ("hipCtxGetStreamPriorityRange", CONV_CONTEXT, API_DRIVER, HIP_UNSUPPORTED)), + ("cuCtxPopCurrent_v2", ("hipCtxPopCurrent", CONV_CONTEXT, API_DRIVER)), + ("cuCtxPushCurrent_v2", ("hipCtxPushCurrent", CONV_CONTEXT, API_DRIVER)), + ("cuCtxSetCacheConfig", ("hipCtxSetCacheConfig", CONV_CONTEXT, API_DRIVER)), + ("cuCtxSetCurrent", ("hipCtxSetCurrent", CONV_CONTEXT, API_DRIVER)), + ("cuCtxSetLimit", ("hipCtxSetLimit", CONV_CONTEXT, API_DRIVER, HIP_UNSUPPORTED)), + ("cuCtxSetSharedMemConfig", ("hipCtxSetSharedMemConfig", CONV_CONTEXT, API_DRIVER)), + ("cuCtxSynchronize", ("hipCtxSynchronize", CONV_CONTEXT, API_DRIVER)), + ("cuCtxAttach", ("hipCtxAttach", CONV_CONTEXT, API_DRIVER, HIP_UNSUPPORTED)), + ("cuCtxDetach", ("hipCtxDetach", CONV_CONTEXT, API_DRIVER, HIP_UNSUPPORTED)), + ("cuCtxEnablePeerAccess", ("hipCtxEnablePeerAccess", CONV_PEER, API_DRIVER)), + ("cuCtxDisablePeerAccess", ("hipCtxDisablePeerAccess", CONV_PEER, API_DRIVER)), + ("cuDeviceCanAccessPeer", ("hipDeviceCanAccessPeer", CONV_PEER, API_DRIVER)), + ("cuDeviceGetP2PAttribute", ("hipDeviceGetP2PAttribute", CONV_PEER, API_DRIVER, HIP_UNSUPPORTED)), + ("cuDevicePrimaryCtxGetState", ("hipDevicePrimaryCtxGetState", CONV_CONTEXT, API_DRIVER)), + ("cuDevicePrimaryCtxRelease", ("hipDevicePrimaryCtxRelease", CONV_CONTEXT, API_DRIVER)), + ("cuDevicePrimaryCtxReset", ("hipDevicePrimaryCtxReset", CONV_CONTEXT, API_DRIVER)), + ("cuDevicePrimaryCtxRetain", ("hipDevicePrimaryCtxRetain", CONV_CONTEXT, API_DRIVER)), + ("cuDevicePrimaryCtxSetFlags", ("hipDevicePrimaryCtxSetFlags", CONV_CONTEXT, API_DRIVER)), + ("cuDeviceGet", ("hipGetDevice", CONV_DEVICE, API_DRIVER)), + ("cuDeviceGetName", ("hipDeviceGetName", CONV_DEVICE, API_DRIVER)), + ("cuDeviceGetCount", ("hipGetDeviceCount", CONV_DEVICE, API_DRIVER)), + ("cuDeviceGetAttribute", ("hipDeviceGetAttribute", CONV_DEVICE, API_DRIVER)), + ("cuDeviceGetPCIBusId", ("hipDeviceGetPCIBusId", CONV_DEVICE, API_DRIVER)), + ("cuDeviceGetByPCIBusId", ("hipDeviceGetByPCIBusId", CONV_DEVICE, API_DRIVER)), + ("cuDeviceTotalMem_v2", ("hipDeviceTotalMem", CONV_DEVICE, API_DRIVER)), + ("cuDeviceComputeCapability", ("hipDeviceComputeCapability", CONV_DEVICE, API_DRIVER)), + ("cuDeviceGetProperties", ("hipGetDeviceProperties", CONV_DEVICE, API_DRIVER)), + ("cuLinkAddData", ("hipLinkAddData", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED)), + ("cuLinkAddFile", ("hipLinkAddFile", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED)), + ("cuLinkComplete", ("hipLinkComplete", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED)), + ("cuLinkCreate", ("hipLinkCreate", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED)), + ("cuLinkDestroy", ("hipLinkDestroy", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED)), + ("cuModuleGetFunction", ("hipModuleGetFunction", CONV_MODULE, API_DRIVER)), + ("cuModuleGetGlobal_v2", ("hipModuleGetGlobal", CONV_MODULE, API_DRIVER)), + ("cuModuleGetSurfRef", ("hipModuleGetSurfRef", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED)), + ("cuModuleGetTexRef", ("hipModuleGetTexRef", CONV_MODULE, API_DRIVER)), + ("cuModuleLoad", ("hipModuleLoad", CONV_MODULE, API_DRIVER)), + ("cuModuleLoadData", ("hipModuleLoadData", CONV_MODULE, API_DRIVER)), + ("cuModuleLoadDataEx", ("hipModuleLoadDataEx", CONV_MODULE, API_DRIVER)), + ("cuModuleLoadFatBinary", ("hipModuleLoadFatBinary", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED)), + ("cuModuleUnload", ("hipModuleUnload", CONV_MODULE, API_DRIVER)), + ("CU_DEVICE_P2P_ATTRIBUTE_PERFORMANCE_RANK", ("hipDeviceP2PAttributePerformanceRank", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_P2P_ATTRIBUTE_ACCESS_SUPPORTED", ("hipDeviceP2PAttributeAccessSupported", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_DEVICE_P2P_ATTRIBUTE_NATIVE_ATOMIC_SUPPORTED", ("hipDeviceP2PAttributeNativeAtomicSupported", CONV_TYPE, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_EVENT_DEFAULT", ("hipEventDefault", CONV_EVENT, API_DRIVER)), + ("CU_EVENT_BLOCKING_SYNC", ("hipEventBlockingSync", CONV_EVENT, API_DRIVER)), + ("CU_EVENT_DISABLE_TIMING", ("hipEventDisableTiming", CONV_EVENT, API_DRIVER)), + ("CU_EVENT_INTERPROCESS", ("hipEventInterprocess", CONV_EVENT, API_DRIVER)), + ("cuEventCreate", ("hipEventCreate", CONV_EVENT, API_DRIVER)), + ("cuEventDestroy_v2", ("hipEventDestroy", CONV_EVENT, API_DRIVER)), + ("cuEventElapsedTime", ("hipEventElapsedTime", CONV_EVENT, API_DRIVER)), + ("cuEventQuery", ("hipEventQuery", CONV_EVENT, API_DRIVER)), + ("cuEventRecord", ("hipEventRecord", CONV_EVENT, API_DRIVER)), + ("cuEventSynchronize", ("hipEventSynchronize", CONV_EVENT, API_DRIVER)), + ("cuFuncGetAttribute", ("hipFuncGetAttribute", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED)), + ("cuFuncSetCacheConfig", ("hipFuncSetCacheConfig", CONV_MODULE, API_DRIVER)), + ("cuFuncSetSharedMemConfig", ("hipFuncSetSharedMemConfig", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED)), + ("cuLaunchKernel", ("hipModuleLaunchKernel", CONV_MODULE, API_DRIVER)), + ("cuFuncSetBlockShape", ("hipFuncSetBlockShape", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED)), + ("cuFuncSetSharedSize", ("hipFuncSetSharedSize", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED)), + ("cuLaunch", ("hipLaunch", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED)), + ("cuLaunchGrid", ("hipLaunchGrid", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED)), + ("cuLaunchGridAsync", ("hipLaunchGridAsync", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED)), + ("cuParamSetf", ("hipParamSetf", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED)), + ("cuParamSeti", ("hipParamSeti", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED)), + ("cuParamSetSize", ("hipParamSetSize", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED)), + ("cuParamSetSize", ("hipParamSetSize", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED)), + ("cuParamSetv", ("hipParamSetv", CONV_MODULE, API_DRIVER, HIP_UNSUPPORTED)), + ("cuOccupancyMaxActiveBlocksPerMultiprocessor", ("hipOccupancyMaxActiveBlocksPerMultiprocessor", CONV_OCCUPANCY, API_DRIVER)), + ("cuOccupancyMaxActiveBlocksPerMultiprocessorWithFlags", ("hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags", CONV_OCCUPANCY, API_DRIVER, HIP_UNSUPPORTED)), + ("cuOccupancyMaxPotentialBlockSize", ("hipOccupancyMaxPotentialBlockSize", CONV_OCCUPANCY, API_DRIVER)), + ("cuOccupancyMaxPotentialBlockSizeWithFlags", ("hipOccupancyMaxPotentialBlockSizeWithFlags", CONV_OCCUPANCY, API_DRIVER, HIP_UNSUPPORTED)), + ("cuStreamAddCallback", ("hipStreamAddCallback", CONV_STREAM, API_DRIVER)), + ("cuStreamAttachMemAsync", ("hipStreamAttachMemAsync", CONV_STREAM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuStreamCreate", ("hipStreamCreate__", CONV_STREAM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuStreamCreateWithPriority", ("hipStreamCreateWithPriority", CONV_STREAM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuStreamDestroy_v2", ("hipStreamDestroy", CONV_STREAM, API_DRIVER)), + ("cuStreamGetFlags", ("hipStreamGetFlags", CONV_STREAM, API_DRIVER)), + ("cuStreamGetPriority", ("hipStreamGetPriority", CONV_STREAM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuStreamQuery", ("hipStreamQuery", CONV_STREAM, API_DRIVER)), + ("cuStreamSynchronize", ("hipStreamSynchronize", CONV_STREAM, API_DRIVER)), + ("cuStreamWaitEvent", ("hipStreamWaitEvent", CONV_STREAM, API_DRIVER)), + ("cuStreamWaitValue32", ("hipStreamWaitValue32", CONV_STREAM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuStreamWriteValue32", ("hipStreamWriteValue32", CONV_STREAM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuStreamBatchMemOp", ("hipStreamBatchMemOp", CONV_STREAM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuArray3DCreate", ("hipArray3DCreate", CONV_MEM, API_DRIVER)), + ("cuArray3DGetDescriptor", ("hipArray3DGetDescriptor", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuArrayCreate", ("hipArrayCreate", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuArrayDestroy", ("hipArrayDestroy", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuArrayGetDescriptor", ("hipArrayGetDescriptor", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuIpcCloseMemHandle", ("hipIpcCloseMemHandle", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuIpcGetEventHandle", ("hipIpcGetEventHandle", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuIpcGetMemHandle", ("hipIpcGetMemHandle", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuIpcOpenEventHandle", ("hipIpcOpenEventHandle", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuIpcOpenMemHandle", ("hipIpcOpenMemHandle", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemAlloc_v2", ("hipMalloc", CONV_MEM, API_DRIVER)), + ("cuMemAllocHost", ("hipMemAllocHost", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemAllocManaged", ("hipMemAllocManaged", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemAllocPitch", ("hipMemAllocPitch__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemcpy", ("hipMemcpy__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemcpy2D", ("hipMemcpy2D__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemcpy2DAsync", ("hipMemcpy2DAsync__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemcpy2DUnaligned", ("hipMemcpy2DUnaligned", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemcpy3D", ("hipMemcpy3D__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemcpy3DAsync", ("hipMemcpy3DAsync__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemcpy3DPeer", ("hipMemcpy3DPeer__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemcpy3DPeerAsync", ("hipMemcpy3DPeerAsync__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemcpyAsync", ("hipMemcpyAsync__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemcpyAtoA", ("hipMemcpyAtoA", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemcpyAtoD", ("hipMemcpyAtoD", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemcpyAtoH", ("hipMemcpyAtoH", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemcpyAtoHAsync", ("hipMemcpyAtoHAsync", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemcpyDtoA", ("hipMemcpyDtoA", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemcpyDtoD_v2", ("hipMemcpyDtoD", CONV_MEM, API_DRIVER)), + ("cuMemcpyDtoDAsync_v2", ("hipMemcpyDtoDAsync", CONV_MEM, API_DRIVER)), + ("cuMemcpyDtoH_v2", ("hipMemcpyDtoH", CONV_MEM, API_DRIVER)), + ("cuMemcpyDtoHAsync_v2", ("hipMemcpyDtoHAsync", CONV_MEM, API_DRIVER)), + ("cuMemcpyHtoA", ("hipMemcpyHtoA", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemcpyHtoAAsync", ("hipMemcpyHtoAAsync", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemcpyHtoD_v2", ("hipMemcpyHtoD", CONV_MEM, API_DRIVER)), + ("cuMemcpyHtoDAsync_v2", ("hipMemcpyHtoDAsync", CONV_MEM, API_DRIVER)), + ("cuMemcpyPeerAsync", ("hipMemcpyPeerAsync__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemcpyPeer", ("hipMemcpyPeer__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemFree_v2", ("hipFree", CONV_MEM, API_DRIVER)), + ("cuMemFreeHost", ("hipHostFree", CONV_MEM, API_DRIVER)), + ("cuMemGetAddressRange", ("hipMemGetAddressRange", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemGetInfo_v2", ("hipMemGetInfo", CONV_MEM, API_DRIVER)), + ("cuMemHostAlloc", ("hipHostMalloc", CONV_MEM, API_DRIVER)), + ("cuMemHostGetDevicePointer", ("hipMemHostGetDevicePointer", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemHostGetFlags", ("hipMemHostGetFlags", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemHostRegister_v2", ("hipHostRegister", CONV_MEM, API_DRIVER)), + ("cuMemHostUnregister", ("hipHostUnregister", CONV_MEM, API_DRIVER)), + ("cuMemsetD16_v2", ("hipMemsetD16", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemsetD16Async", ("hipMemsetD16Async", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemsetD2D16_v2", ("hipMemsetD2D16", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemsetD2D16Async", ("hipMemsetD2D16Async", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemsetD2D32_v2", ("hipMemsetD2D32", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemsetD2D32Async", ("hipMemsetD2D32Async", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemsetD2D8_v2", ("hipMemsetD2D8", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemsetD2D8Async", ("hipMemsetD2D8Async", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemsetD32_v2", ("hipMemset", CONV_MEM, API_DRIVER)), + ("cuMemsetD32Async", ("hipMemsetAsync", CONV_MEM, API_DRIVER)), + ("cuMemsetD8_v2", ("hipMemsetD8", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemsetD8Async", ("hipMemsetD8Async", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMipmappedArrayCreate", ("hipMipmappedArrayCreate", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMipmappedArrayDestroy", ("hipMipmappedArrayDestroy", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMipmappedArrayGetLevel", ("hipMipmappedArrayGetLevel", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemPrefetchAsync", ("hipMemPrefetchAsync__", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemAdvise", ("hipMemAdvise", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemRangeGetAttribute", ("hipMemRangeGetAttribute", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuMemRangeGetAttributes", ("hipMemRangeGetAttributes", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuPointerGetAttribute", ("hipPointerGetAttribute", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuPointerGetAttributes", ("hipPointerGetAttributes", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("cuPointerSetAttribute", ("hipPointerSetAttribute", CONV_MEM, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_TR_FILTER_MODE_POINT", ("hipFilterModePoint", CONV_TEX, API_DRIVER)), + ("CU_TR_FILTER_MODE_LINEAR", ("hipFilterModeLinear", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("cuTexRefGetAddress", ("hipTexRefGetAddress", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("cuTexRefGetAddressMode", ("hipTexRefGetAddressMode", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("cuTexRefGetArray", ("hipTexRefGetArray", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("cuTexRefGetBorderColor", ("hipTexRefGetBorderColor", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("cuTexRefGetFilterMode", ("hipTexRefGetFilterMode", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("cuTexRefGetFlags", ("hipTexRefGetFlags", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("cuTexRefGetFormat", ("hipTexRefGetFormat", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("cuTexRefGetMaxAnisotropy", ("hipTexRefGetMaxAnisotropy", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("cuTexRefGetMipmapFilterMode", ("hipTexRefGetMipmapFilterMode", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("cuTexRefGetMipmapLevelBias", ("hipTexRefGetMipmapLevelBias", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("cuTexRefGetMipmapLevelClamp", ("hipTexRefGetMipmapLevelClamp", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("cuTexRefGetMipmappedArray", ("hipTexRefGetMipmappedArray", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("cuTexRefSetAddress", ("hipTexRefSetAddress", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("cuTexRefSetAddress2D", ("hipTexRefSetAddress2D", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("cuTexRefSetAddressMode", ("hipTexRefSetAddressMode", CONV_TEX, API_DRIVER)), + ("cuTexRefSetArray", ("hipTexRefSetArray", CONV_TEX, API_DRIVER)), + ("cuTexRefSetBorderColor", ("hipTexRefSetBorderColor", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("cuTexRefSetFilterMode", ("hipTexRefSetFilterMode", CONV_TEX, API_DRIVER)), + ("cuTexRefSetFlags", ("hipTexRefSetFlags", CONV_TEX, API_DRIVER)), + ("cuTexRefSetFormat", ("hipTexRefSetFormat", CONV_TEX, API_DRIVER)), + ("cuTexRefSetMaxAnisotropy", ("hipTexRefSetMaxAnisotropy", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("cuTexRefSetMipmapFilterMode", ("hipTexRefSetMipmapFilterMode", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("cuTexRefSetMipmapLevelBias", ("hipTexRefSetMipmapLevelBias", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("cuTexRefSetMipmapLevelClamp", ("hipTexRefSetMipmapLevelClamp", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("cuTexRefSetMipmappedArray", ("hipTexRefSetMipmappedArray", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("cuTexRefCreate", ("hipTexRefCreate", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("cuTexRefDestroy", ("hipTexRefDestroy", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("cuSurfRefGetArray", ("hipSurfRefGetArray", CONV_SURFACE, API_DRIVER, HIP_UNSUPPORTED)), + ("cuSurfRefSetArray", ("hipSurfRefSetArray", CONV_SURFACE, API_DRIVER, HIP_UNSUPPORTED)), + ("cuTexObjectCreate", ("hipTexObjectCreate", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("cuTexObjectDestroy", ("hipTexObjectDestroy", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("cuTexObjectGetResourceDesc", ("hipTexObjectGetResourceDesc", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("cuTexObjectGetResourceViewDesc", ("hipTexObjectGetResourceViewDesc", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("cuTexObjectGetTextureDesc", ("hipTexObjectGetTextureDesc", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("cuSurfObjectCreate", ("hipSurfObjectCreate", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("cuSurfObjectDestroy", ("hipSurfObjectDestroy", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("cuSurfObjectGetResourceDesc", ("hipSurfObjectGetResourceDesc", CONV_TEX, API_DRIVER, HIP_UNSUPPORTED)), + ("cuGraphicsMapResources", ("hipGraphicsMapResources", CONV_GRAPHICS, API_DRIVER, HIP_UNSUPPORTED)), + ("cuGraphicsResourceGetMappedMipmappedArray", ("hipGraphicsResourceGetMappedMipmappedArray", CONV_GRAPHICS, API_DRIVER, HIP_UNSUPPORTED)), + ("cuGraphicsResourceGetMappedPointer", ("hipGraphicsResourceGetMappedPointer", CONV_GRAPHICS, API_DRIVER, HIP_UNSUPPORTED)), + ("cuGraphicsResourceSetMapFlags", ("hipGraphicsResourceSetMapFlags", CONV_GRAPHICS, API_DRIVER, HIP_UNSUPPORTED)), + ("cuGraphicsSubResourceGetMappedArray", ("hipGraphicsSubResourceGetMappedArray", CONV_GRAPHICS, API_DRIVER, HIP_UNSUPPORTED)), + ("cuGraphicsUnmapResources", ("hipGraphicsUnmapResources", CONV_GRAPHICS, API_DRIVER, HIP_UNSUPPORTED)), + ("cuGraphicsUnregisterResource", ("hipGraphicsUnregisterResource", CONV_GRAPHICS, API_DRIVER, HIP_UNSUPPORTED)), + ("cuProfilerInitialize", ("hipProfilerInitialize", CONV_OTHER, API_DRIVER, HIP_UNSUPPORTED)), + ("cuProfilerStart", ("hipProfilerStart", CONV_OTHER, API_DRIVER)), + ("cuProfilerStop", ("hipProfilerStop", CONV_OTHER, API_DRIVER)), + ("CU_GL_DEVICE_LIST_ALL", ("HIP_GL_DEVICE_LIST_ALL", CONV_GL, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_GL_DEVICE_LIST_CURRENT_FRAME", ("HIP_GL_DEVICE_LIST_CURRENT_FRAME", CONV_GL, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_GL_DEVICE_LIST_NEXT_FRAME", ("HIP_GL_DEVICE_LIST_NEXT_FRAME", CONV_GL, API_DRIVER, HIP_UNSUPPORTED)), + ("cuGLGetDevices", ("hipGLGetDevices", CONV_GL, API_DRIVER, HIP_UNSUPPORTED)), + ("cuGraphicsGLRegisterBuffer", ("hipGraphicsGLRegisterBuffer", CONV_GL, API_DRIVER, HIP_UNSUPPORTED)), + ("cuGraphicsGLRegisterImage", ("hipGraphicsGLRegisterImage", CONV_GL, API_DRIVER, HIP_UNSUPPORTED)), + ("cuWGLGetDevice", ("hipWGLGetDevice", CONV_GL, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_GL_MAP_RESOURCE_FLAGS_NONE", ("HIP_GL_MAP_RESOURCE_FLAGS_NONE", CONV_GL, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_GL_MAP_RESOURCE_FLAGS_READ_ONLY", ("HIP_GL_MAP_RESOURCE_FLAGS_READ_ONLY", CONV_GL, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_GL_MAP_RESOURCE_FLAGS_WRITE_DISCARD", ("HIP_GL_MAP_RESOURCE_FLAGS_WRITE_DISCARD", CONV_GL, API_DRIVER, HIP_UNSUPPORTED)), + ("cuGLCtxCreate", ("hipGLCtxCreate", CONV_GL, API_DRIVER, HIP_UNSUPPORTED)), + ("cuGLInit", ("hipGLInit", CONV_GL, API_DRIVER, HIP_UNSUPPORTED)), + ("cuGLMapBufferObject", ("hipGLMapBufferObject", CONV_GL, API_DRIVER, HIP_UNSUPPORTED)), + ("cuGLMapBufferObjectAsync", ("hipGLMapBufferObjectAsync", CONV_GL, API_DRIVER, HIP_UNSUPPORTED)), + ("cuGLRegisterBufferObject", ("hipGLRegisterBufferObject", CONV_GL, API_DRIVER, HIP_UNSUPPORTED)), + ("cuGLSetBufferObjectMapFlags", ("hipGLSetBufferObjectMapFlags", CONV_GL, API_DRIVER, HIP_UNSUPPORTED)), + ("cuGLUnmapBufferObject", ("hipGLUnmapBufferObject", CONV_GL, API_DRIVER, HIP_UNSUPPORTED)), + ("cuGLUnmapBufferObjectAsync", ("hipGLUnmapBufferObjectAsync", CONV_GL, API_DRIVER, HIP_UNSUPPORTED)), + ("cuGLUnregisterBufferObject", ("hipGLUnregisterBufferObject", CONV_GL, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_D3D9_DEVICE_LIST_ALL", ("HIP_D3D9_DEVICE_LIST_ALL", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_D3D9_DEVICE_LIST_CURRENT_FRAME", ("HIP_D3D9_DEVICE_LIST_CURRENT_FRAME", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_D3D9_DEVICE_LIST_NEXT_FRAME", ("HIP_D3D9_DEVICE_LIST_NEXT_FRAME", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D9CtxCreate", ("hipD3D9CtxCreate", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D9CtxCreateOnDevice", ("hipD3D9CtxCreateOnDevice", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D9GetDevice", ("hipD3D9GetDevice", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D9GetDevices", ("hipD3D9GetDevices", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D9GetDirect3DDevice", ("hipD3D9GetDirect3DDevice", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED)), + ("cuGraphicsD3D9RegisterResource", ("hipGraphicsD3D9RegisterResource", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_D3D9_MAPRESOURCE_FLAGS_NONE", ("HIP_D3D9_MAPRESOURCE_FLAGS_NONE", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_D3D9_MAPRESOURCE_FLAGS_READONLY", ("HIP_D3D9_MAPRESOURCE_FLAGS_READONLY", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_D3D9_MAPRESOURCE_FLAGS_WRITEDISCARD", ("HIP_D3D9_MAPRESOURCE_FLAGS_WRITEDISCARD", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_D3D9_REGISTER_FLAGS_NONE", ("HIP_D3D9_REGISTER_FLAGS_NONE", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_D3D9_REGISTER_FLAGS_ARRAY", ("HIP_D3D9_REGISTER_FLAGS_ARRAY", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D9MapResources", ("hipD3D9MapResources", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D9RegisterResource", ("hipD3D9RegisterResource", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D9ResourceGetMappedArray", ("hipD3D9ResourceGetMappedArray", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D9ResourceGetMappedPitch", ("hipD3D9ResourceGetMappedPitch", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D9ResourceGetMappedPointer", ("hipD3D9ResourceGetMappedPointer", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D9ResourceGetMappedSize", ("hipD3D9ResourceGetMappedSize", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D9ResourceGetSurfaceDimensions", ("hipD3D9ResourceGetSurfaceDimensions", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D9ResourceSetMapFlags", ("hipD3D9ResourceSetMapFlags", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D9UnmapResources", ("hipD3D9UnmapResources", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D9UnregisterResource", ("hipD3D9UnregisterResource", CONV_D3D9, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_D3D10_DEVICE_LIST_ALL", ("HIP_D3D10_DEVICE_LIST_ALL", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_D3D10_DEVICE_LIST_CURRENT_FRAME", ("HIP_D3D10_DEVICE_LIST_CURRENT_FRAME", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_D3D10_DEVICE_LIST_NEXT_FRAME", ("HIP_D3D10_DEVICE_LIST_NEXT_FRAME", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D10GetDevice", ("hipD3D10GetDevice", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D10GetDevices", ("hipD3D10GetDevices", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED)), + ("cuGraphicsD3D10RegisterResource", ("hipGraphicsD3D10RegisterResource", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_D3D10_MAPRESOURCE_FLAGS_NONE", ("HIP_D3D10_MAPRESOURCE_FLAGS_NONE", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_D3D10_MAPRESOURCE_FLAGS_READONLY", ("HIP_D3D10_MAPRESOURCE_FLAGS_READONLY", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_D3D10_MAPRESOURCE_FLAGS_WRITEDISCARD", ("HIP_D3D10_MAPRESOURCE_FLAGS_WRITEDISCARD", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_D3D10_REGISTER_FLAGS_NONE", ("HIP_D3D10_REGISTER_FLAGS_NONE", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_D3D10_REGISTER_FLAGS_ARRAY", ("HIP_D3D10_REGISTER_FLAGS_ARRAY", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D10CtxCreate", ("hipD3D10CtxCreate", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D10CtxCreateOnDevice", ("hipD3D10CtxCreateOnDevice", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D10GetDirect3DDevice", ("hipD3D10GetDirect3DDevice", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D10MapResources", ("hipD3D10MapResources", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D10RegisterResource", ("hipD3D10RegisterResource", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D10ResourceGetMappedArray", ("hipD3D10ResourceGetMappedArray", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D10ResourceGetMappedPitch", ("hipD3D10ResourceGetMappedPitch", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D10ResourceGetMappedPointer", ("hipD3D10ResourceGetMappedPointer", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D10ResourceGetMappedSize", ("hipD3D10ResourceGetMappedSize", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D10ResourceGetSurfaceDimensions", ("hipD3D10ResourceGetSurfaceDimensions", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD310ResourceSetMapFlags", ("hipD3D10ResourceSetMapFlags", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D10UnmapResources", ("hipD3D10UnmapResources", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D10UnregisterResource", ("hipD3D10UnregisterResource", CONV_D3D10, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_D3D11_DEVICE_LIST_ALL", ("HIP_D3D11_DEVICE_LIST_ALL", CONV_D3D11, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_D3D11_DEVICE_LIST_CURRENT_FRAME", ("HIP_D3D11_DEVICE_LIST_CURRENT_FRAME", CONV_D3D11, API_DRIVER, HIP_UNSUPPORTED)), + ("CU_D3D11_DEVICE_LIST_NEXT_FRAME", ("HIP_D3D11_DEVICE_LIST_NEXT_FRAME", CONV_D3D11, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D11GetDevice", ("hipD3D11GetDevice", CONV_D3D11, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D11GetDevices", ("hipD3D11GetDevices", CONV_D3D11, API_DRIVER, HIP_UNSUPPORTED)), + ("cuGraphicsD3D11RegisterResource", ("hipGraphicsD3D11RegisterResource", CONV_D3D11, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D11CtxCreate", ("hipD3D11CtxCreate", CONV_D3D11, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D11CtxCreateOnDevice", ("hipD3D11CtxCreateOnDevice", CONV_D3D11, API_DRIVER, HIP_UNSUPPORTED)), + ("cuD3D11GetDirect3DDevice", ("hipD3D11GetDirect3DDevice", CONV_D3D11, API_DRIVER, HIP_UNSUPPORTED)), + ("cuGraphicsVDPAURegisterOutputSurface", ("hipGraphicsVDPAURegisterOutputSurface", CONV_VDPAU, API_DRIVER, HIP_UNSUPPORTED)), + ("cuGraphicsVDPAURegisterVideoSurface", ("hipGraphicsVDPAURegisterVideoSurface", CONV_VDPAU, API_DRIVER, HIP_UNSUPPORTED)), + ("cuVDPAUGetDevice", ("hipVDPAUGetDevice", CONV_VDPAU, API_DRIVER, HIP_UNSUPPORTED)), + ("cuVDPAUCtxCreate", ("hipVDPAUCtxCreate", CONV_VDPAU, API_DRIVER, HIP_UNSUPPORTED)), + ("cuEGLStreamConsumerAcquireFrame", ("hipEGLStreamConsumerAcquireFrame", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED)), + ("cuEGLStreamConsumerConnect", ("hipEGLStreamConsumerConnect", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED)), + ("cuEGLStreamConsumerConnectWithFlags", ("hipEGLStreamConsumerConnectWithFlags", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED)), + ("cuEGLStreamConsumerDisconnect", ("hipEGLStreamConsumerDisconnect", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED)), + ("cuEGLStreamConsumerReleaseFrame", ("hipEGLStreamConsumerReleaseFrame", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED)), + ("cuEGLStreamProducerConnect", ("hipEGLStreamProducerConnect", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED)), + ("cuEGLStreamProducerDisconnect", ("hipEGLStreamProducerDisconnect", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED)), + ("cuEGLStreamProducerPresentFrame", ("hipEGLStreamProducerPresentFrame", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED)), + ("cuEGLStreamProducerReturnFrame", ("hipEGLStreamProducerReturnFrame", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED)), + ("cuGraphicsEGLRegisterImage", ("hipGraphicsEGLRegisterImage", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED)), + ("cuGraphicsResourceGetMappedEglFrame", ("hipGraphicsResourceGetMappedEglFrame", CONV_EGL, API_DRIVER, HIP_UNSUPPORTED)), + ("cudaDataType_t", ("hipDataType_t", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDataType", ("hipDataType_t", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_R_16F", ("hipR16F", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_C_16F", ("hipC16F", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_R_32F", ("hipR32F", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_C_32F", ("hipC32F", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_R_64F", ("hipR64F", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_C_64F", ("hipC64F", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_R_8I", ("hipR8I", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_C_8I", ("hipC8I", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_R_8U", ("hipR8U", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_C_8U", ("hipC8U", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_R_32I", ("hipR32I", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_C_32I", ("hipC32I", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_R_32U", ("hipR32U", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("CUDA_C_32U", ("hipC32U", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("MAJOR_VERSION", ("hipLibraryMajorVersion", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("MINOR_VERSION", ("hipLibraryMinorVersion", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("PATCH_LEVEL", ("hipLibraryPatchVersion", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMemAttachGlobal", ("hipMemAttachGlobal", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMemAttachHost", ("hipMemAttachHost", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMemAttachSingle", ("hipMemAttachSingle", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaOccupancyDefault", ("hipOccupancyDefault", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaOccupancyDisableCachingOverride", ("hipOccupancyDisableCachingOverride", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGetLastError", ("hipGetLastError", CONV_ERROR, API_RUNTIME)), + ("cudaPeekAtLastError", ("hipPeekAtLastError", CONV_ERROR, API_RUNTIME)), + ("cudaGetErrorName", ("hipGetErrorName", CONV_ERROR, API_RUNTIME)), + ("cudaGetErrorString", ("hipGetErrorString", CONV_ERROR, API_RUNTIME)), + ("cudaMemcpy3DParms", ("hipMemcpy3DParms", CONV_MEM, API_RUNTIME)), + ("cudaMemcpy3DPeerParms", ("hipMemcpy3DPeerParms", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMemcpy", ("hipMemcpy", CONV_MEM, API_RUNTIME)), + ("cudaMemcpyToArray", ("hipMemcpyToArray", CONV_MEM, API_RUNTIME)), + ("cudaMemcpyToSymbol", ("hipMemcpyToSymbol", CONV_MEM, API_RUNTIME)), + ("cudaMemcpyToSymbolAsync", ("hipMemcpyToSymbolAsync", CONV_MEM, API_RUNTIME)), + ("cudaMemcpyAsync", ("hipMemcpyAsync", CONV_MEM, API_RUNTIME)), + ("cudaMemcpy2D", ("hipMemcpy2D", CONV_MEM, API_RUNTIME)), + ("cudaMemcpy2DAsync", ("hipMemcpy2DAsync", CONV_MEM, API_RUNTIME)), + ("cudaMemcpy2DToArray", ("hipMemcpy2DToArray", CONV_MEM, API_RUNTIME)), + ("cudaMemcpy2DArrayToArray", ("hipMemcpy2DArrayToArray", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMemcpy2DFromArray", ("hipMemcpy2DFromArray", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMemcpy2DFromArrayAsync", ("hipMemcpy2DFromArrayAsync", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMemcpy2DToArrayAsync", ("hipMemcpy2DToArrayAsync", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMemcpy3D", ("hipMemcpy3D", CONV_MEM, API_RUNTIME)), + ("cudaMemcpy3DAsync", ("hipMemcpy3DAsync", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMemcpy3DPeer", ("hipMemcpy3DPeer", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMemcpy3DPeerAsync", ("hipMemcpy3DPeerAsync", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMemcpyArrayToArray", ("hipMemcpyArrayToArray", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMemcpyFromArrayAsync", ("hipMemcpyFromArrayAsync", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMemcpyFromSymbol", ("hipMemcpyFromSymbol", CONV_MEM, API_RUNTIME)), + ("cudaMemcpyFromSymbolAsync", ("hipMemcpyFromSymbolAsync", CONV_MEM, API_RUNTIME)), + ("cudaMemAdvise", ("hipMemAdvise", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMemRangeGetAttribute", ("hipMemRangeGetAttribute", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMemRangeGetAttributes", ("hipMemRangeGetAttributes", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMemAdviseSetReadMostly", ("hipMemAdviseSetReadMostly", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMemAdviseUnsetReadMostly", ("hipMemAdviseUnsetReadMostly", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMemAdviseSetPreferredLocation", ("hipMemAdviseSetPreferredLocation", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMemAdviseUnsetPreferredLocation", ("hipMemAdviseUnsetPreferredLocation", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMemAdviseSetAccessedBy", ("hipMemAdviseSetAccessedBy", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMemAdviseUnsetAccessedBy", ("hipMemAdviseUnsetAccessedBy", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMemRangeAttributeReadMostly", ("hipMemRangeAttributeReadMostly", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMemRangeAttributePreferredLocation", ("hipMemRangeAttributePreferredLocation", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMemRangeAttributeAccessedBy", ("hipMemRangeAttributeAccessedBy", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMemRangeAttributeLastPrefetchLocation", ("hipMemRangeAttributeLastPrefetchLocation", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMemcpyHostToHost", ("hipMemcpyHostToHost", CONV_MEM, API_RUNTIME)), + ("cudaMemcpyHostToDevice", ("hipMemcpyHostToDevice", CONV_MEM, API_RUNTIME)), + ("cudaMemcpyDeviceToHost", ("hipMemcpyDeviceToHost", CONV_MEM, API_RUNTIME)), + ("cudaMemcpyDeviceToDevice", ("hipMemcpyDeviceToDevice", CONV_MEM, API_RUNTIME)), + ("cudaMemcpyDefault", ("hipMemcpyDefault", CONV_MEM, API_RUNTIME)), + ("cudaMemset", ("hipMemset", CONV_MEM, API_RUNTIME)), + ("cudaMemsetAsync", ("hipMemsetAsync", CONV_MEM, API_RUNTIME)), + ("cudaMemset2D", ("hipMemset2D", CONV_MEM, API_RUNTIME)), + ("cudaMemset2DAsync", ("hipMemset2DAsync", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMemset3D", ("hipMemset3D", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMemset3DAsync", ("hipMemset3DAsync", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMemGetInfo", ("hipMemGetInfo", CONV_MEM, API_RUNTIME)), + ("cudaArrayGetInfo", ("hipArrayGetInfo", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaFreeMipmappedArray", ("hipFreeMipmappedArray", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGetMipmappedArrayLevel", ("hipGetMipmappedArrayLevel", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGetSymbolAddress", ("hipGetSymbolAddress", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGetSymbolSize", ("hipGetSymbolSize", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMemPrefetchAsync", ("hipMemPrefetchAsync", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMalloc", ("hipMalloc", CONV_MEM, API_RUNTIME)), + ("cudaMallocHost", ("hipHostMalloc", CONV_MEM, API_RUNTIME)), + ("cudaMallocArray", ("hipMallocArray", CONV_MEM, API_RUNTIME)), + ("cudaMalloc3D", ("hipMalloc3D", CONV_MEM, API_RUNTIME)), + ("cudaMalloc3DArray", ("hipMalloc3DArray", CONV_MEM, API_RUNTIME)), + ("cudaMallocManaged", ("hipMallocManaged", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMallocMipmappedArray", ("hipMallocMipmappedArray", CONV_MEM, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaMallocPitch", ("hipMallocPitch", CONV_MEM, API_RUNTIME)), + ("cudaFree", ("hipFree", CONV_MEM, API_RUNTIME)), + ("cudaFreeHost", ("hipHostFree", CONV_MEM, API_RUNTIME)), + ("cudaFreeArray", ("hipFreeArray", CONV_MEM, API_RUNTIME)), + ("cudaHostRegister", ("hipHostRegister", CONV_MEM, API_RUNTIME)), + ("cudaHostUnregister", ("hipHostUnregister", CONV_MEM, API_RUNTIME)), + ("cudaHostAlloc", ("hipHostMalloc", CONV_MEM, API_RUNTIME)), + ("cudaMemoryTypeHost", ("hipMemoryTypeHost", CONV_MEM, API_RUNTIME)), + ("cudaMemoryTypeDevice", ("hipMemoryTypeDevice", CONV_MEM, API_RUNTIME)), + ("make_cudaExtent", ("make_hipExtent", CONV_MEM, API_RUNTIME)), + ("make_cudaPitchedPtr", ("make_hipPitchedPtr", CONV_MEM, API_RUNTIME)), + ("make_cudaPos", ("make_hipPos", CONV_MEM, API_RUNTIME)), + ("cudaHostAllocDefault", ("hipHostMallocDefault", CONV_MEM, API_RUNTIME)), + ("cudaHostAllocPortable", ("hipHostMallocPortable", CONV_MEM, API_RUNTIME)), + ("cudaHostAllocMapped", ("hipHostMallocMapped", CONV_MEM, API_RUNTIME)), + ("cudaHostAllocWriteCombined", ("hipHostMallocWriteCombined", CONV_MEM, API_RUNTIME)), + ("cudaHostGetFlags", ("hipHostGetFlags", CONV_MEM, API_RUNTIME)), + ("cudaHostRegisterDefault", ("hipHostRegisterDefault", CONV_MEM, API_RUNTIME)), + ("cudaHostRegisterPortable", ("hipHostRegisterPortable", CONV_MEM, API_RUNTIME)), + ("cudaHostRegisterMapped", ("hipHostRegisterMapped", CONV_MEM, API_RUNTIME)), + ("cudaHostRegisterIoMemory", ("hipHostRegisterIoMemory", CONV_MEM, API_RUNTIME)), + # ("warpSize", ("hipWarpSize", CONV_SPECIAL_FUNC, API_RUNTIME), (HIP actually uses warpSize...), + ("cudaEventCreate", ("hipEventCreate", CONV_EVENT, API_RUNTIME)), + ("cudaEventCreateWithFlags", ("hipEventCreateWithFlags", CONV_EVENT, API_RUNTIME)), + ("cudaEventDestroy", ("hipEventDestroy", CONV_EVENT, API_RUNTIME)), + ("cudaEventRecord", ("hipEventRecord", CONV_EVENT, API_RUNTIME)), + ("cudaEventElapsedTime", ("hipEventElapsedTime", CONV_EVENT, API_RUNTIME)), + ("cudaEventSynchronize", ("hipEventSynchronize", CONV_EVENT, API_RUNTIME)), + ("cudaEventQuery", ("hipEventQuery", CONV_EVENT, API_RUNTIME)), + ("cudaEventDefault", ("hipEventDefault", CONV_EVENT, API_RUNTIME)), + ("cudaEventBlockingSync", ("hipEventBlockingSync", CONV_EVENT, API_RUNTIME)), + ("cudaEventDisableTiming", ("hipEventDisableTiming", CONV_EVENT, API_RUNTIME)), + ("cudaEventInterprocess", ("hipEventInterprocess", CONV_EVENT, API_RUNTIME)), + ("cudaStreamCreate", ("hipStreamCreate", CONV_STREAM, API_RUNTIME)), + ("cudaStreamCreateWithFlags", ("hipStreamCreateWithFlags", CONV_STREAM, API_RUNTIME)), + ("cudaStreamCreateWithPriority", ("hipStreamCreateWithPriority", CONV_STREAM, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaStreamDestroy", ("hipStreamDestroy", CONV_STREAM, API_RUNTIME)), + ("cudaStreamWaitEvent", ("hipStreamWaitEvent", CONV_STREAM, API_RUNTIME)), + ("cudaStreamSynchronize", ("hipStreamSynchronize", CONV_STREAM, API_RUNTIME)), + ("cudaStreamGetFlags", ("hipStreamGetFlags", CONV_STREAM, API_RUNTIME)), + ("cudaStreamQuery", ("hipStreamQuery", CONV_STREAM, API_RUNTIME)), + ("cudaStreamAddCallback", ("hipStreamAddCallback", CONV_STREAM, API_RUNTIME)), + ("cudaStreamAttachMemAsync", ("hipStreamAttachMemAsync", CONV_STREAM, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaStreamGetPriority", ("hipStreamGetPriority", CONV_STREAM, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaStreamDefault", ("hipStreamDefault", CONV_TYPE, API_RUNTIME)), + ("cudaStreamNonBlocking", ("hipStreamNonBlocking", CONV_TYPE, API_RUNTIME)), + ("cudaDeviceSynchronize", ("hipDeviceSynchronize", CONV_DEVICE, API_RUNTIME)), + ("cudaDeviceReset", ("hipDeviceReset", CONV_DEVICE, API_RUNTIME)), + ("cudaSetDevice", ("hipSetDevice", CONV_DEVICE, API_RUNTIME)), + ("cudaGetDevice", ("hipGetDevice", CONV_DEVICE, API_RUNTIME)), + ("cudaGetDeviceCount", ("hipGetDeviceCount", CONV_DEVICE, API_RUNTIME)), + ("cudaChooseDevice", ("hipChooseDevice", CONV_DEVICE, API_RUNTIME)), + ("cudaThreadExit", ("hipDeviceReset", CONV_THREAD, API_RUNTIME)), + ("cudaThreadGetCacheConfig", ("hipDeviceGetCacheConfig", CONV_THREAD, API_RUNTIME)), + ("cudaThreadGetLimit", ("hipThreadGetLimit", CONV_THREAD, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaThreadSetCacheConfig", ("hipDeviceSetCacheConfig", CONV_THREAD, API_RUNTIME)), + ("cudaThreadSetLimit", ("hipThreadSetLimit", CONV_THREAD, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaThreadSynchronize", ("hipDeviceSynchronize", CONV_THREAD, API_RUNTIME)), + ("cudaDeviceGetAttribute", ("hipDeviceGetAttribute", CONV_DEVICE, API_RUNTIME)), + ("cudaDevAttrMaxThreadsPerBlock", ("hipDeviceAttributeMaxThreadsPerBlock", CONV_TYPE, API_RUNTIME)), + ("cudaDevAttrMaxBlockDimX", ("hipDeviceAttributeMaxBlockDimX", CONV_TYPE, API_RUNTIME)), + ("cudaDevAttrMaxBlockDimY", ("hipDeviceAttributeMaxBlockDimY", CONV_TYPE, API_RUNTIME)), + ("cudaDevAttrMaxBlockDimZ", ("hipDeviceAttributeMaxBlockDimZ", CONV_TYPE, API_RUNTIME)), + ("cudaDevAttrMaxGridDimX", ("hipDeviceAttributeMaxGridDimX", CONV_TYPE, API_RUNTIME)), + ("cudaDevAttrMaxGridDimY", ("hipDeviceAttributeMaxGridDimY", CONV_TYPE, API_RUNTIME)), + ("cudaDevAttrMaxGridDimZ", ("hipDeviceAttributeMaxGridDimZ", CONV_TYPE, API_RUNTIME)), + ("cudaDevAttrMaxSharedMemoryPerBlock", ("hipDeviceAttributeMaxSharedMemoryPerBlock", CONV_TYPE, API_RUNTIME)), + ("cudaDevAttrTotalConstantMemory", ("hipDeviceAttributeTotalConstantMemory", CONV_TYPE, API_RUNTIME)), + ("cudaDevAttrWarpSize", ("hipDeviceAttributeWarpSize", CONV_TYPE, API_RUNTIME)), + ("cudaDevAttrMaxPitch", ("hipDeviceAttributeMaxPitch", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxRegistersPerBlock", ("hipDeviceAttributeMaxRegistersPerBlock", CONV_TYPE, API_RUNTIME)), + ("cudaDevAttrClockRate", ("hipDeviceAttributeClockRate", CONV_TYPE, API_RUNTIME)), + ("cudaDevAttrTextureAlignment", ("hipDeviceAttributeTextureAlignment", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrGpuOverlap", ("hipDeviceAttributeGpuOverlap", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMultiProcessorCount", ("hipDeviceAttributeMultiprocessorCount", CONV_TYPE, API_RUNTIME)), + ("cudaDevAttrKernelExecTimeout", ("hipDeviceAttributeKernelExecTimeout", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrIntegrated", ("hipDeviceAttributeIntegrated", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrCanMapHostMemory", ("hipDeviceAttributeCanMapHostMemory", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrComputeMode", ("hipDeviceAttributeComputeMode", CONV_TYPE, API_RUNTIME)), + ("cudaDevAttrMaxTexture1DWidth", ("hipDeviceAttributeMaxTexture1DWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxTexture2DWidth", ("hipDeviceAttributeMaxTexture2DWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxTexture2DHeight", ("hipDeviceAttributeMaxTexture2DHeight", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxTexture3DWidth", ("hipDeviceAttributeMaxTexture3DWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxTexture3DHeight", ("hipDeviceAttributeMaxTexture3DHeight", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxTexture3DDepth", ("hipDeviceAttributeMaxTexture3DDepth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxTexture2DLayeredWidth", ("hipDeviceAttributeMaxTexture2DLayeredWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxTexture2DLayeredHeight", ("hipDeviceAttributeMaxTexture2DLayeredHeight", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxTexture2DLayeredLayers", ("hipDeviceAttributeMaxTexture2DLayeredLayers", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrSurfaceAlignment", ("hipDeviceAttributeSurfaceAlignment", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrConcurrentKernels", ("hipDeviceAttributeConcurrentKernels", CONV_TYPE, API_RUNTIME)), + ("cudaDevAttrEccEnabled", ("hipDeviceAttributeEccEnabled", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrPciBusId", ("hipDeviceAttributePciBusId", CONV_TYPE, API_RUNTIME)), + ("cudaDevAttrPciDeviceId", ("hipDeviceAttributePciDeviceId", CONV_TYPE, API_RUNTIME)), + ("cudaDevAttrTccDriver", ("hipDeviceAttributeTccDriver", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMemoryClockRate", ("hipDeviceAttributeMemoryClockRate", CONV_TYPE, API_RUNTIME)), + ("cudaDevAttrGlobalMemoryBusWidth", ("hipDeviceAttributeMemoryBusWidth", CONV_TYPE, API_RUNTIME)), + ("cudaDevAttrL2CacheSize", ("hipDeviceAttributeL2CacheSize", CONV_TYPE, API_RUNTIME)), + ("cudaDevAttrMaxThreadsPerMultiProcessor", ("hipDeviceAttributeMaxThreadsPerMultiProcessor", CONV_TYPE, API_RUNTIME)), + ("cudaDevAttrAsyncEngineCount", ("hipDeviceAttributeAsyncEngineCount", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrUnifiedAddressing", ("hipDeviceAttributeUnifiedAddressing", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxTexture1DLayeredWidth", ("hipDeviceAttributeMaxTexture1DLayeredWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxTexture1DLayeredLayers", ("hipDeviceAttributeMaxTexture1DLayeredLayers", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxTexture2DGatherWidth", ("hipDeviceAttributeMaxTexture2DGatherWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxTexture2DGatherHeight", ("hipDeviceAttributeMaxTexture2DGatherHeight", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxTexture3DWidthAlt", ("hipDeviceAttributeMaxTexture3DWidthAlternate", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxTexture3DHeightAlt", ("hipDeviceAttributeMaxTexture3DHeightAlternate", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxTexture3DDepthAlt", ("hipDeviceAttributeMaxTexture3DDepthAlternate", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrPciDomainId", ("hipDeviceAttributePciDomainId", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrTexturePitchAlignment", ("hipDeviceAttributeTexturePitchAlignment", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxTextureCubemapWidth", ("hipDeviceAttributeMaxTextureCubemapWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxTextureCubemapLayeredWidth", ("hipDeviceAttributeMaxTextureCubemapLayeredWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxTextureCubemapLayeredLayers", ("hipDeviceAttributeMaxTextureCubemapLayeredLayers", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxSurface1DWidth", ("hipDeviceAttributeMaxSurface1DWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxSurface2DWidth", ("hipDeviceAttributeMaxSurface2DWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxSurface2DHeight", ("hipDeviceAttributeMaxSurface2DHeight", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxSurface3DWidth", ("hipDeviceAttributeMaxSurface3DWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxSurface3DHeight", ("hipDeviceAttributeMaxSurface3DHeight", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxSurface3DDepth", ("hipDeviceAttributeMaxSurface3DDepth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxSurface1DLayeredWidth", ("hipDeviceAttributeMaxSurface1DLayeredWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxSurface1DLayeredLayers", ("hipDeviceAttributeMaxSurface1DLayeredLayers", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxSurface2DLayeredWidth", ("hipDeviceAttributeMaxSurface2DLayeredWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxSurface2DLayeredHeight", ("hipDeviceAttributeMaxSurface2DLayeredHeight", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxSurface2DLayeredLayers", ("hipDeviceAttributeMaxSurface2DLayeredLayers", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxSurfaceCubemapWidth", ("hipDeviceAttributeMaxSurfaceCubemapWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxSurfaceCubemapLayeredWidth", ("hipDeviceAttributeMaxSurfaceCubemapLayeredWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxSurfaceCubemapLayeredLayers", ("hipDeviceAttributeMaxSurfaceCubemapLayeredLayers", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxTexture1DLinearWidth", ("hipDeviceAttributeMaxTexture1DLinearWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxTexture2DLinearWidth", ("hipDeviceAttributeMaxTexture2DLinearWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxTexture2DLinearHeight", ("hipDeviceAttributeMaxTexture2DLinearHeight", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxTexture2DLinearPitch", ("hipDeviceAttributeMaxTexture2DLinearPitch", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxTexture2DMipmappedWidth", ("hipDeviceAttributeMaxTexture2DMipmappedWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxTexture2DMipmappedHeight", ("hipDeviceAttributeMaxTexture2DMipmappedHeight", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrComputeCapabilityMajor", ("hipDeviceAttributeComputeCapabilityMajor", CONV_TYPE, API_RUNTIME)), + ("cudaDevAttrComputeCapabilityMinor", ("hipDeviceAttributeComputeCapabilityMinor", CONV_TYPE, API_RUNTIME)), + ("cudaDevAttrMaxTexture1DMipmappedWidth", ("hipDeviceAttributeMaxTexture1DMipmappedWidth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrStreamPrioritiesSupported", ("hipDeviceAttributeStreamPrioritiesSupported", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrGlobalL1CacheSupported", ("hipDeviceAttributeGlobalL1CacheSupported", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrLocalL1CacheSupported", ("hipDeviceAttributeLocalL1CacheSupported", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrMaxSharedMemoryPerMultiprocessor", ("hipDeviceAttributeMaxSharedMemoryPerMultiprocessor", CONV_TYPE, API_RUNTIME)), + ("cudaDevAttrMaxRegistersPerMultiprocessor", ("hipDeviceAttributeMaxRegistersPerMultiprocessor", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrManagedMemory", ("hipDeviceAttributeManagedMemory", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrIsMultiGpuBoard", ("hipDeviceAttributeIsMultiGpuBoard", CONV_TYPE, API_RUNTIME)), + ("cudaDevAttrMultiGpuBoardGroupID", ("hipDeviceAttributeMultiGpuBoardGroupID", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrHostNativeAtomicSupported", ("hipDeviceAttributeHostNativeAtomicSupported", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrSingleToDoublePrecisionPerfRatio", ("hipDeviceAttributeSingleToDoublePrecisionPerfRatio", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrPageableMemoryAccess", ("hipDeviceAttributePageableMemoryAccess", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrConcurrentManagedAccess", ("hipDeviceAttributeConcurrentManagedAccess", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrComputePreemptionSupported", ("hipDeviceAttributeComputePreemptionSupported", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevAttrCanUseHostPointerForRegisteredMem", ("hipDeviceAttributeCanUseHostPointerForRegisteredMem", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaPointerGetAttributes", ("hipPointerGetAttributes", CONV_MEM, API_RUNTIME)), + ("cudaHostGetDevicePointer", ("hipHostGetDevicePointer", CONV_MEM, API_RUNTIME)), + ("cudaGetDeviceProperties", ("hipGetDeviceProperties", CONV_DEVICE, API_RUNTIME)), + ("cudaDeviceGetPCIBusId", ("hipDeviceGetPCIBusId", CONV_DEVICE, API_RUNTIME)), + ("cudaDeviceGetByPCIBusId", ("hipDeviceGetByPCIBusId", CONV_DEVICE, API_RUNTIME)), + ("cudaDeviceGetStreamPriorityRange", ("hipDeviceGetStreamPriorityRange", CONV_DEVICE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaSetValidDevices", ("hipSetValidDevices", CONV_DEVICE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevP2PAttrPerformanceRank", ("hipDeviceP2PAttributePerformanceRank", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevP2PAttrAccessSupported", ("hipDeviceP2PAttributeAccessSupported", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDevP2PAttrNativeAtomicSupported", ("hipDeviceP2PAttributeNativeAtomicSupported", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDeviceGetP2PAttribute", ("hipDeviceGetP2PAttribute", CONV_DEVICE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaComputeModeDefault", ("hipComputeModeDefault", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaComputeModeExclusive", ("hipComputeModeExclusive", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaComputeModeProhibited", ("hipComputeModeProhibited", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaComputeModeExclusiveProcess", ("hipComputeModeExclusiveProcess", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGetDeviceFlags", ("hipGetDeviceFlags", CONV_DEVICE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaSetDeviceFlags", ("hipSetDeviceFlags", CONV_DEVICE, API_RUNTIME)), + ("cudaDeviceScheduleAuto", ("hipDeviceScheduleAuto", CONV_TYPE, API_RUNTIME)), + ("cudaDeviceScheduleSpin", ("hipDeviceScheduleSpin", CONV_TYPE, API_RUNTIME)), + ("cudaDeviceScheduleYield", ("hipDeviceScheduleYield", CONV_TYPE, API_RUNTIME)), + ("cudaDeviceBlockingSync", ("hipDeviceScheduleBlockingSync", CONV_TYPE, API_RUNTIME)), + ("cudaDeviceScheduleBlockingSync", ("hipDeviceScheduleBlockingSync", CONV_TYPE, API_RUNTIME)), + ("cudaDeviceScheduleMask", ("hipDeviceScheduleMask", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDeviceMapHost", ("hipDeviceMapHost", CONV_TYPE, API_RUNTIME)), + ("cudaDeviceLmemResizeToMax", ("hipDeviceLmemResizeToMax", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDeviceMask", ("hipDeviceMask", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDeviceSetCacheConfig", ("hipDeviceSetCacheConfig", CONV_CACHE, API_RUNTIME)), + ("cudaDeviceGetCacheConfig", ("hipDeviceGetCacheConfig", CONV_CACHE, API_RUNTIME)), + ("cudaFuncSetCacheConfig", ("hipFuncSetCacheConfig", CONV_CACHE, API_RUNTIME)), + ("cudaFuncCachePreferNone", ("hipFuncCachePreferNone", CONV_CACHE, API_RUNTIME)), + ("cudaFuncCachePreferShared", ("hipFuncCachePreferShared", CONV_CACHE, API_RUNTIME)), + ("cudaFuncCachePreferL1", ("hipFuncCachePreferL1", CONV_CACHE, API_RUNTIME)), + ("cudaFuncCachePreferEqual", ("hipFuncCachePreferEqual", CONV_CACHE, API_RUNTIME)), + ("cudaFuncGetAttributes", ("hipFuncGetAttributes", CONV_EXEC, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaFuncSetSharedMemConfig", ("hipFuncSetSharedMemConfig", CONV_EXEC, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGetParameterBuffer", ("hipGetParameterBuffer", CONV_EXEC, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaSetDoubleForDevice", ("hipSetDoubleForDevice", CONV_EXEC, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaSetDoubleForHost", ("hipSetDoubleForHost", CONV_EXEC, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaConfigureCall", ("hipConfigureCall", CONV_EXEC, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaLaunch", ("hipLaunch", CONV_EXEC, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaSetupArgument", ("hipSetupArgument", CONV_EXEC, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDriverGetVersion", ("hipDriverGetVersion", CONV_VERSION, API_RUNTIME)), + ("cudaRuntimeGetVersion", ("hipRuntimeGetVersion", CONV_VERSION, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaOccupancyMaxPotentialBlockSize", ("hipOccupancyMaxPotentialBlockSize", CONV_OCCUPANCY, API_RUNTIME)), + ("cudaOccupancyMaxPotentialBlockSizeWithFlags", ("hipOccupancyMaxPotentialBlockSizeWithFlags", CONV_OCCUPANCY, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaOccupancyMaxActiveBlocksPerMultiprocessor", ("hipOccupancyMaxActiveBlocksPerMultiprocessor", CONV_OCCUPANCY, API_RUNTIME)), + ("cudaOccupancyMaxActiveBlocksPerMultiprocessorWithFlags", ("hipOccupancyMaxActiveBlocksPerMultiprocessorWithFlags", CONV_OCCUPANCY, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaOccupancyMaxPotentialBlockSizeVariableSMem", ("hipOccupancyMaxPotentialBlockSizeVariableSMem", CONV_OCCUPANCY, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaOccupancyMaxPotentialBlockSizeVariableSMemWithFlags", ("hipOccupancyMaxPotentialBlockSizeVariableSMemWithFlags", CONV_OCCUPANCY, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDeviceCanAccessPeer", ("hipDeviceCanAccessPeer", CONV_PEER, API_RUNTIME)), + ("cudaDeviceDisablePeerAccess", ("hipDeviceDisablePeerAccess", CONV_PEER, API_RUNTIME)), + ("cudaDeviceEnablePeerAccess", ("hipDeviceEnablePeerAccess", CONV_PEER, API_RUNTIME)), + ("cudaMemcpyPeerAsync", ("hipMemcpyPeerAsync", CONV_MEM, API_RUNTIME)), + ("cudaMemcpyPeer", ("hipMemcpyPeer", CONV_MEM, API_RUNTIME)), + ("cudaIpcMemLazyEnablePeerAccess", ("hipIpcMemLazyEnablePeerAccess", CONV_TYPE, API_RUNTIME)), + ("cudaDeviceSetSharedMemConfig", ("hipDeviceSetSharedMemConfig", CONV_DEVICE, API_RUNTIME)), + ("cudaDeviceGetSharedMemConfig", ("hipDeviceGetSharedMemConfig", CONV_DEVICE, API_RUNTIME)), + ("cudaSharedMemBankSizeDefault", ("hipSharedMemBankSizeDefault", CONV_TYPE, API_RUNTIME)), + ("cudaSharedMemBankSizeFourByte", ("hipSharedMemBankSizeFourByte", CONV_TYPE, API_RUNTIME)), + ("cudaSharedMemBankSizeEightByte", ("hipSharedMemBankSizeEightByte", CONV_TYPE, API_RUNTIME)), + ("cudaLimitStackSize", ("hipLimitStackSize", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaLimitPrintfFifoSize", ("hipLimitPrintfFifoSize", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaLimitMallocHeapSize", ("hipLimitMallocHeapSize", CONV_TYPE, API_RUNTIME)), + ("cudaLimitDevRuntimeSyncDepth", ("hipLimitDevRuntimeSyncDepth", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaLimitDevRuntimePendingLaunchCount", ("hipLimitDevRuntimePendingLaunchCount", CONV_TYPE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDeviceGetLimit", ("hipDeviceGetLimit", CONV_DEVICE, API_RUNTIME)), + ("cudaProfilerInitialize", ("hipProfilerInitialize", CONV_OTHER, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaProfilerStart", ("hipProfilerStart", CONV_OTHER, API_RUNTIME)), + ("cudaProfilerStop", ("hipProfilerStop", CONV_OTHER, API_RUNTIME)), + ("cudaKeyValuePair", ("hipKeyValuePair", CONV_OTHER, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaCSV", ("hipCSV", CONV_OTHER, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaReadModeElementType", ("hipReadModeElementType", CONV_TEX, API_RUNTIME)), + ("cudaReadModeNormalizedFloat", ("hipReadModeNormalizedFloat", CONV_TEX, API_RUNTIME)), + ("cudaFilterModePoint", ("hipFilterModePoint", CONV_TEX, API_RUNTIME)), + ("cudaFilterModeLinear", ("hipFilterModeLinear", CONV_TEX, API_RUNTIME)), + ("cudaBindTexture", ("hipBindTexture", CONV_TEX, API_RUNTIME)), + ("cudaUnbindTexture", ("hipUnbindTexture", CONV_TEX, API_RUNTIME)), + ("cudaBindTexture2D", ("hipBindTexture2D", CONV_TEX, API_RUNTIME)), + ("cudaBindTextureToArray", ("hipBindTextureToArray", CONV_TEX, API_RUNTIME)), + ("cudaBindTextureToMipmappedArray", ("hipBindTextureToMipmappedArray", CONV_TEX, API_RUNTIME)), + ("cudaGetTextureAlignmentOffset", ("hipGetTextureAlignmentOffset", CONV_TEX, API_RUNTIME)), + ("cudaGetTextureReference", ("hipGetTextureReference", CONV_TEX, API_RUNTIME)), + ("cudaChannelFormatKindSigned", ("hipChannelFormatKindSigned", CONV_TEX, API_RUNTIME)), + ("cudaChannelFormatKindUnsigned", ("hipChannelFormatKindUnsigned", CONV_TEX, API_RUNTIME)), + ("cudaChannelFormatKindFloat", ("hipChannelFormatKindFloat", CONV_TEX, API_RUNTIME)), + ("cudaChannelFormatKindNone", ("hipChannelFormatKindNone", CONV_TEX, API_RUNTIME)), + ("cudaCreateChannelDesc", ("hipCreateChannelDesc", CONV_TEX, API_RUNTIME)), + ("cudaGetChannelDesc", ("hipGetChannelDesc", CONV_TEX, API_RUNTIME)), + ("cudaResourceTypeArray", ("hipResourceTypeArray", CONV_TEX, API_RUNTIME)), + ("cudaResourceTypeMipmappedArray", ("hipResourceTypeMipmappedArray", CONV_TEX, API_RUNTIME)), + ("cudaResourceTypeLinear", ("hipResourceTypeLinear", CONV_TEX, API_RUNTIME)), + ("cudaResourceTypePitch2D", ("hipResourceTypePitch2D", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatNone", ("hipResViewFormatNone", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatUnsignedChar1", ("hipResViewFormatUnsignedChar1", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatUnsignedChar2", ("hipResViewFormatUnsignedChar2", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatUnsignedChar4", ("hipResViewFormatUnsignedChar4", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatSignedChar1", ("hipResViewFormatSignedChar1", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatSignedChar2", ("hipResViewFormatSignedChar2", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatSignedChar4", ("hipResViewFormatSignedChar4", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatUnsignedShort1", ("hipResViewFormatUnsignedShort1", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatUnsignedShort2", ("hipResViewFormatUnsignedShort2", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatUnsignedShort4", ("hipResViewFormatUnsignedShort4", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatSignedShort1", ("hipResViewFormatSignedShort1", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatSignedShort2", ("hipResViewFormatSignedShort2", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatSignedShort4", ("hipResViewFormatSignedShort4", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatUnsignedInt1", ("hipResViewFormatUnsignedInt1", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatUnsignedInt2", ("hipResViewFormatUnsignedInt2", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatUnsignedInt4", ("hipResViewFormatUnsignedInt4", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatSignedInt1", ("hipResViewFormatSignedInt1", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatSignedInt2", ("hipResViewFormatSignedInt2", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatSignedInt4", ("hipResViewFormatSignedInt4", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatHalf1", ("hipResViewFormatHalf1", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatHalf2", ("hipResViewFormatHalf2", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatHalf4", ("hipResViewFormatHalf4", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatFloat1", ("hipResViewFormatFloat1", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatFloat2", ("hipResViewFormatFloat2", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatFloat4", ("hipResViewFormatFloat4", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatUnsignedBlockCompressed1", ("hipResViewFormatUnsignedBlockCompressed1", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatUnsignedBlockCompressed2", ("hipResViewFormatUnsignedBlockCompressed2", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatUnsignedBlockCompressed3", ("hipResViewFormatUnsignedBlockCompressed3", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatUnsignedBlockCompressed4", ("hipResViewFormatUnsignedBlockCompressed4", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatSignedBlockCompressed4", ("hipResViewFormatSignedBlockCompressed4", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatUnsignedBlockCompressed5", ("hipResViewFormatUnsignedBlockCompressed5", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatSignedBlockCompressed5", ("hipResViewFormatSignedBlockCompressed5", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatUnsignedBlockCompressed6H", ("hipResViewFormatUnsignedBlockCompressed6H", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatSignedBlockCompressed6H", ("hipResViewFormatSignedBlockCompressed6H", CONV_TEX, API_RUNTIME)), + ("cudaResViewFormatUnsignedBlockCompressed7", ("hipResViewFormatUnsignedBlockCompressed7", CONV_TEX, API_RUNTIME)), + ("cudaAddressModeWrap", ("hipAddressModeWrap", CONV_TEX, API_RUNTIME)), + ("cudaAddressModeClamp", ("hipAddressModeClamp", CONV_TEX, API_RUNTIME)), + ("cudaAddressModeMirror", ("hipAddressModeMirror", CONV_TEX, API_RUNTIME)), + ("cudaAddressModeBorder", ("hipAddressModeBorder", CONV_TEX, API_RUNTIME)), + ("cudaCreateTextureObject", ("hipCreateTextureObject", CONV_TEX, API_RUNTIME)), + ("cudaDestroyTextureObject", ("hipDestroyTextureObject", CONV_TEX, API_RUNTIME)), + ("cudaGetTextureObjectResourceDesc", ("hipGetTextureObjectResourceDesc", CONV_TEX, API_RUNTIME)), + ("cudaGetTextureObjectResourceViewDesc", ("hipGetTextureObjectResourceViewDesc", CONV_TEX, API_RUNTIME)), + ("cudaGetTextureObjectTextureDesc", ("hipGetTextureObjectTextureDesc", CONV_TEX, API_RUNTIME)), + ("cudaBindSurfaceToArray", ("hipBindSurfaceToArray", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGetSurfaceReference", ("hipGetSurfaceReference", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaBoundaryModeZero", ("hipBoundaryModeZero", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaBoundaryModeClamp", ("hipBoundaryModeClamp", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaBoundaryModeTrap", ("hipBoundaryModeTrap", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaFormatModeForced", ("hipFormatModeForced", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaFormatModeAuto", ("hipFormatModeAuto", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaCreateSurfaceObject", ("hipCreateSurfaceObject", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaDestroySurfaceObject", ("hipDestroySurfaceObject", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGetSurfaceObjectResourceDesc", ("hipGetSurfaceObjectResourceDesc", CONV_SURFACE, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaIpcCloseMemHandle", ("hipIpcCloseMemHandle", CONV_DEVICE, API_RUNTIME)), + ("cudaIpcGetEventHandle", ("hipIpcGetEventHandle", CONV_DEVICE, API_RUNTIME)), + ("cudaIpcGetMemHandle", ("hipIpcGetMemHandle", CONV_DEVICE, API_RUNTIME)), + ("cudaIpcOpenEventHandle", ("hipIpcOpenEventHandle", CONV_DEVICE, API_RUNTIME)), + ("cudaIpcOpenMemHandle", ("hipIpcOpenMemHandle", CONV_DEVICE, API_RUNTIME)), + ("cudaGLGetDevices", ("hipGLGetDevices", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsGLRegisterBuffer", ("hipGraphicsGLRegisterBuffer", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsGLRegisterImage", ("hipGraphicsGLRegisterImage", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaWGLGetDevice", ("hipWGLGetDevice", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsMapResources", ("hipGraphicsMapResources", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsResourceGetMappedMipmappedArray", ("hipGraphicsResourceGetMappedMipmappedArray", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsResourceGetMappedPointer", ("hipGraphicsResourceGetMappedPointer", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsResourceSetMapFlags", ("hipGraphicsResourceSetMapFlags", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsSubResourceGetMappedArray", ("hipGraphicsSubResourceGetMappedArray", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsUnmapResources", ("hipGraphicsUnmapResources", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsUnregisterResource", ("hipGraphicsUnregisterResource", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsCubeFacePositiveX", ("hipGraphicsCubeFacePositiveX", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsCubeFaceNegativeX", ("hipGraphicsCubeFaceNegativeX", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsCubeFacePositiveY", ("hipGraphicsCubeFacePositiveY", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsCubeFaceNegativeY", ("hipGraphicsCubeFaceNegativeY", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsCubeFacePositiveZ", ("hipGraphicsCubeFacePositiveZ", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsCubeFaceNegativeZ", ("hipGraphicsCubeFaceNegativeZ", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsMapFlagsNone", ("hipGraphicsMapFlagsNone", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsMapFlagsReadOnly", ("hipGraphicsMapFlagsReadOnly", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsMapFlagsWriteDiscard", ("hipGraphicsMapFlagsWriteDiscard", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsRegisterFlagsNone", ("hipGraphicsRegisterFlagsNone", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsRegisterFlagsReadOnly", ("hipGraphicsRegisterFlagsReadOnly", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsRegisterFlagsWriteDiscard", ("hipGraphicsRegisterFlagsWriteDiscard", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsRegisterFlagsSurfaceLoadStore", ("hipGraphicsRegisterFlagsSurfaceLoadStore", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsRegisterFlagsTextureGather", ("hipGraphicsRegisterFlagsTextureGather", CONV_GRAPHICS, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGLDeviceListAll", ("HIP_GL_DEVICE_LIST_ALL", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGLDeviceListCurrentFrame", ("HIP_GL_DEVICE_LIST_CURRENT_FRAME", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGLDeviceListNextFrame", ("HIP_GL_DEVICE_LIST_NEXT_FRAME", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGLGetDevices", ("hipGLGetDevices", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsGLRegisterBuffer", ("hipGraphicsGLRegisterBuffer", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsGLRegisterImage", ("hipGraphicsGLRegisterImage", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaWGLGetDevice", ("hipWGLGetDevice", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGLMapFlagsNone", ("HIP_GL_MAP_RESOURCE_FLAGS_NONE", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGLMapFlagsReadOnly", ("HIP_GL_MAP_RESOURCE_FLAGS_READ_ONLY", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGLMapFlagsWriteDiscard", ("HIP_GL_MAP_RESOURCE_FLAGS_WRITE_DISCARD", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGLMapBufferObject", ("hipGLMapBufferObject__", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGLMapBufferObjectAsync", ("hipGLMapBufferObjectAsync__", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGLRegisterBufferObject", ("hipGLRegisterBufferObject", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGLSetBufferObjectMapFlags", ("hipGLSetBufferObjectMapFlags", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGLSetGLDevice", ("hipGLSetGLDevice", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGLUnmapBufferObject", ("hipGLUnmapBufferObject", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGLUnmapBufferObjectAsync", ("hipGLUnmapBufferObjectAsync", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGLUnregisterBufferObject", ("hipGLUnregisterBufferObject", CONV_GL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D9DeviceListAll", ("HIP_D3D9_DEVICE_LIST_ALL", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D9DeviceListCurrentFrame", ("HIP_D3D9_DEVICE_LIST_CURRENT_FRAME", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D9DeviceListNextFrame", ("HIP_D3D9_DEVICE_LIST_NEXT_FRAME", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D9GetDevice", ("hipD3D9GetDevice", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D9GetDevices", ("hipD3D9GetDevices", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D9GetDirect3DDevice", ("hipD3D9GetDirect3DDevice", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D9SetDirect3DDevice", ("hipD3D9SetDirect3DDevice", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsD3D9RegisterResource", ("hipGraphicsD3D9RegisterResource", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D9MapFlags", ("hipD3D9MapFlags", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D9MapFlagsNone", ("HIP_D3D9_MAPRESOURCE_FLAGS_NONE", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D9MapFlagsReadOnly", ("HIP_D3D9_MAPRESOURCE_FLAGS_READONLY", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D9MapFlagsWriteDiscard", ("HIP_D3D9_MAPRESOURCE_FLAGS_WRITEDISCARD", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D9RegisterFlagsNone", ("HIP_D3D9_REGISTER_FLAGS_NONE", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D9RegisterFlagsArray", ("HIP_D3D9_REGISTER_FLAGS_ARRAY", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D9MapResources", ("hipD3D9MapResources", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D9RegisterResource", ("hipD3D9RegisterResource", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D9ResourceGetMappedArray", ("hipD3D9ResourceGetMappedArray", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D9ResourceGetMappedPitch", ("hipD3D9ResourceGetMappedPitch", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D9ResourceGetMappedPointer", ("hipD3D9ResourceGetMappedPointer", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D9ResourceGetMappedSize", ("hipD3D9ResourceGetMappedSize", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D9ResourceGetSurfaceDimensions", ("hipD3D9ResourceGetSurfaceDimensions", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D9ResourceSetMapFlags", ("hipD3D9ResourceSetMapFlags", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D9UnmapResources", ("hipD3D9UnmapResources", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D9UnregisterResource", ("hipD3D9UnregisterResource", CONV_D3D9, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D10DeviceListAll", ("HIP_D3D10_DEVICE_LIST_ALL", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D10DeviceListCurrentFrame", ("HIP_D3D10_DEVICE_LIST_CURRENT_FRAME", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D10DeviceListNextFrame", ("HIP_D3D10_DEVICE_LIST_NEXT_FRAME", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D10GetDevice", ("hipD3D10GetDevice", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D10GetDevices", ("hipD3D10GetDevices", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsD3D10RegisterResource", ("hipGraphicsD3D10RegisterResource", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D10MapFlagsNone", ("HIP_D3D10_MAPRESOURCE_FLAGS_NONE", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D10MapFlagsReadOnly", ("HIP_D3D10_MAPRESOURCE_FLAGS_READONLY", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D10MapFlagsWriteDiscard", ("HIP_D3D10_MAPRESOURCE_FLAGS_WRITEDISCARD", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D10RegisterFlagsNone", ("HIP_D3D10_REGISTER_FLAGS_NONE", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D10RegisterFlagsArray", ("HIP_D3D10_REGISTER_FLAGS_ARRAY", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D10GetDirect3DDevice", ("hipD3D10GetDirect3DDevice", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D10MapResources", ("hipD3D10MapResources", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D10RegisterResource", ("hipD3D10RegisterResource", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D10ResourceGetMappedArray", ("hipD3D10ResourceGetMappedArray", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D10ResourceGetMappedPitch", ("hipD3D10ResourceGetMappedPitch", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D10ResourceGetMappedPointer", ("hipD3D10ResourceGetMappedPointer", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D10ResourceGetMappedSize", ("hipD3D10ResourceGetMappedSize", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D10ResourceGetSurfaceDimensions", ("hipD3D10ResourceGetSurfaceDimensions", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D10ResourceSetMapFlags", ("hipD3D10ResourceSetMapFlags", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D10SetDirect3DDevice", ("hipD3D10SetDirect3DDevice", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D10UnmapResources", ("hipD3D10UnmapResources", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D10UnregisterResource", ("hipD3D10UnregisterResource", CONV_D3D10, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D11DeviceListAll", ("HIP_D3D11_DEVICE_LIST_ALL", CONV_D3D11, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D11DeviceListCurrentFrame", ("HIP_D3D11_DEVICE_LIST_CURRENT_FRAME", CONV_D3D11, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D11DeviceListNextFrame", ("HIP_D3D11_DEVICE_LIST_NEXT_FRAME", CONV_D3D11, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D11GetDevice", ("hipD3D11GetDevice", CONV_D3D11, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D11GetDevices", ("hipD3D11GetDevices", CONV_D3D11, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsD3D11RegisterResource", ("hipGraphicsD3D11RegisterResource", CONV_D3D11, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D11GetDevice", ("hipD3D11GetDevice", CONV_D3D11, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaD3D11GetDevices", ("hipD3D11GetDevices", CONV_D3D11, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsD3D11RegisterResource", ("hipGraphicsD3D11RegisterResource", CONV_D3D11, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsVDPAURegisterOutputSurface", ("hipGraphicsVDPAURegisterOutputSurface", CONV_VDPAU, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsVDPAURegisterVideoSurface", ("hipGraphicsVDPAURegisterVideoSurface", CONV_VDPAU, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaVDPAUGetDevice", ("hipVDPAUGetDevice", CONV_VDPAU, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaVDPAUSetVDPAUDevice", ("hipVDPAUSetDevice", CONV_VDPAU, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaEGLStreamConsumerAcquireFrame", ("hipEGLStreamConsumerAcquireFrame", CONV_EGL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaEGLStreamConsumerConnect", ("hipEGLStreamConsumerConnect", CONV_EGL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaEGLStreamConsumerConnectWithFlags", ("hipEGLStreamConsumerConnectWithFlags", CONV_EGL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaEGLStreamConsumerReleaseFrame", ("hipEGLStreamConsumerReleaseFrame", CONV_EGL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaEGLStreamProducerConnect", ("hipEGLStreamProducerConnect", CONV_EGL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaEGLStreamProducerDisconnect", ("hipEGLStreamProducerDisconnect", CONV_EGL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaEGLStreamProducerPresentFrame", ("hipEGLStreamProducerPresentFrame", CONV_EGL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaEGLStreamProducerReturnFrame", ("hipEGLStreamProducerReturnFrame", CONV_EGL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsEGLRegisterImage", ("hipGraphicsEGLRegisterImage", CONV_EGL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cudaGraphicsResourceGetMappedEglFrame", ("hipGraphicsResourceGetMappedEglFrame", CONV_EGL, API_RUNTIME, HIP_UNSUPPORTED)), + ("cublasInit", ("rocblas_init", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasShutdown", ("rocblas_shutdown", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasGetVersion", ("rocblas_get_version", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasGetError", ("rocblas_get_error", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasAlloc", ("rocblas_alloc", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasFree", ("rocblas_free", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSetKernelStream", ("rocblas_set_kernel_stream", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasGetAtomicsMode", ("rocblas_get_atomics_mode", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSetAtomicsMode", ("rocblas_set_atomics_mode", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasGetMathMode", ("rocblas_get_math_mode", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSetMathMode", ("rocblas_set_math_mode", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("CUBLAS_OP_N", ("rocblas_operation_none", CONV_NUMERIC_LITERAL, API_BLAS)), + ("CUBLAS_OP_T", ("rocblas_operation_transpose", CONV_NUMERIC_LITERAL, API_BLAS)), + ("CUBLAS_OP_C", ("rocblas_operation_conjugate_transpose", CONV_NUMERIC_LITERAL, API_BLAS)), + ("CUBLAS_STATUS_SUCCESS", ("rocblas_status_success", CONV_NUMERIC_LITERAL, API_BLAS)), + ("CUBLAS_STATUS_NOT_INITIALIZED", ("rocblas_status_invalid_handle", CONV_NUMERIC_LITERAL, API_BLAS)), + ("CUBLAS_STATUS_ALLOC_FAILED", ("rocblas_status_memory_error", CONV_NUMERIC_LITERAL, API_BLAS)), + ("CUBLAS_STATUS_INVALID_VALUE", ("rocblas_status_invalid_pointer", CONV_NUMERIC_LITERAL, API_BLAS)), + ("CUBLAS_STATUS_MAPPING_ERROR", ("rocblas_status_internal_error", CONV_NUMERIC_LITERAL, API_BLAS)), + ("CUBLAS_STATUS_EXECUTION_FAILED", ("rocblas_status_internal_error", CONV_NUMERIC_LITERAL, API_BLAS)), + ("CUBLAS_STATUS_INTERNAL_ERROR", ("rocblas_status_internal_error", CONV_NUMERIC_LITERAL, API_BLAS)), + ("CUBLAS_STATUS_NOT_SUPPORTED", ("rocblas_status_not_implemented", CONV_NUMERIC_LITERAL, API_BLAS)), + ("CUBLAS_STATUS_ARCH_MISMATCH", ("rocblas_status_not_implemented", CONV_NUMERIC_LITERAL, API_BLAS)), + ("CUBLAS_FILL_MODE_LOWER", ("rocblas_fill_lower", CONV_NUMERIC_LITERAL, API_BLAS)), + ("CUBLAS_FILL_MODE_UPPER", ("rocblas_fill_upper", CONV_NUMERIC_LITERAL, API_BLAS)), + ("CUBLAS_DIAG_NON_UNIT", ("rocblas_diagonal_non_unit", CONV_NUMERIC_LITERAL, API_BLAS)), + ("CUBLAS_DIAG_UNIT", ("rocblas_diagonal_unit", CONV_NUMERIC_LITERAL, API_BLAS)), + ("CUBLAS_SIDE_LEFT", ("rocblas_side_left", CONV_NUMERIC_LITERAL, API_BLAS)), + ("CUBLAS_SIDE_RIGHT", ("rocblas_side_right", CONV_NUMERIC_LITERAL, API_BLAS)), + ("CUBLAS_POINTER_MODE_HOST", ("rocblas_pointer_mode_host", CONV_NUMERIC_LITERAL, API_BLAS)), + ("CUBLAS_POINTER_MODE_DEVICE", ("rocblas_pointer_mode_device", CONV_NUMERIC_LITERAL, API_BLAS)), + ("CUBLAS_ATOMICS_NOT_ALLOWED", ("rocblas_atomics_not_allowed", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED)), + ("CUBLAS_ATOMICS_ALLOWED", ("rocblas_atomics_allowed", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED)), + ("CUBLAS_DATA_FLOAT", ("rocblas_precision_float", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED)), + ("CUBLAS_DATA_DOUBLE", ("rocblas_precision_double", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED)), + ("CUBLAS_DATA_HALF", ("rocblas_precision_half", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED)), + ("CUBLAS_DATA_INT8", ("rocblas_precision_int8", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCreate", ("rocblas_create_handle", CONV_MATH_FUNC, API_BLAS)), + ("cublasDestroy", ("rocblas_destroy_handle", CONV_MATH_FUNC, API_BLAS)), + ("cublasSetVector", ("rocblas_set_vector", CONV_MATH_FUNC, API_BLAS)), + ("cublasGetVector", ("rocblas_get_vector", CONV_MATH_FUNC, API_BLAS)), + ("cublasSetVectorAsync", ("rocblas_set_vector_async", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasGetVectorAsync", ("rocblas_get_vector_async", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSetMatrix", ("rocblas_set_matrix", CONV_MATH_FUNC, API_BLAS)), + ("cublasGetMatrix", ("rocblas_get_matrix", CONV_MATH_FUNC, API_BLAS)), + ("cublasGetMatrixAsync", ("rocblas_get_matrix_async", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSetMatrixAsync", ("rocblas_set_matrix_async", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasXerbla", ("rocblas_xerbla", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSnrm2", ("rocblas_snrm2", CONV_MATH_FUNC, API_BLAS)), + ("cublasDnrm2", ("rocblas_dnrm2", CONV_MATH_FUNC, API_BLAS)), + ("cublasScnrm2", ("rocblas_scnrm2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDznrm2", ("rocblas_dznrm2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasNrm2Ex", ("rocblas_nrm2_ex", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSdot", ("rocblas_sdot", CONV_MATH_FUNC, API_BLAS)), + ("cublasSdotBatched", ("rocblas_sdot_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDdot", ("rocblas_ddot", CONV_MATH_FUNC, API_BLAS)), + ("cublasDdotBatched", ("rocblas_ddot_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCdotu", ("rocblas_cdotu", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCdotc", ("rocblas_cdotc", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZdotu", ("rocblas_zdotu", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZdotc", ("rocblas_zdotc", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSscal", ("rocblas_sscal", CONV_MATH_FUNC, API_BLAS)), + ("cublasSscalBatched", ("rocblas_sscal_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDscal", ("rocblas_dscal", CONV_MATH_FUNC, API_BLAS)), + ("cublasDscalBatched", ("rocblas_dscal_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCscal", ("rocblas_cscal", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCsscal", ("rocblas_csscal", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZscal", ("rocblas_zscal", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZdscal", ("rocblas_zdscal", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSaxpy", ("rocblas_saxpy", CONV_MATH_FUNC, API_BLAS)), + ("cublasSaxpyBatched", ("rocblas_saxpy_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDaxpy", ("rocblas_daxpy", CONV_MATH_FUNC, API_BLAS)), + ("cublasCaxpy", ("rocblas_caxpy", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZaxpy", ("rocblas_zaxpy", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasScopy", ("rocblas_scopy", CONV_MATH_FUNC, API_BLAS)), + ("cublasScopyBatched", ("rocblas_scopy_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDcopy", ("rocblas_dcopy", CONV_MATH_FUNC, API_BLAS)), + ("cublasDcopyBatched", ("rocblas_dcopy_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCcopy", ("rocblas_ccopy", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZcopy", ("rocblas_zcopy", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSswap", ("rocblas_sswap", CONV_MATH_FUNC, API_BLAS)), + ("cublasDswap", ("rocblas_dswap", CONV_MATH_FUNC, API_BLAS)), + ("cublasCswap", ("rocblas_cswap", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZswap", ("rocblas_zswap", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasIsamax", ("rocblas_isamax", CONV_MATH_FUNC, API_BLAS)), + ("cublasIdamax", ("rocblas_idamax", CONV_MATH_FUNC, API_BLAS)), + ("cublasIcamax", ("rocblas_icamax", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasIzamax", ("rocblas_izamax", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasIsamin", ("rocblas_isamin", CONV_MATH_FUNC, API_BLAS)), + ("cublasIdamin", ("rocblas_idamin", CONV_MATH_FUNC, API_BLAS)), + ("cublasIcamin", ("rocblas_icamin", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasIzamin", ("rocblas_izamin", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSasum", ("rocblas_sasum", CONV_MATH_FUNC, API_BLAS)), + ("cublasSasumBatched", ("rocblas_sasum_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDasum", ("rocblas_dasum", CONV_MATH_FUNC, API_BLAS)), + ("cublasDasumBatched", ("rocblas_dasum_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasScasum", ("rocblas_scasum", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDzasum", ("rocblas_dzasum", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSrot", ("rocblas_srot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDrot", ("rocblas_drot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCrot", ("rocblas_crot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCsrot", ("rocblas_csrot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZrot", ("rocblas_zrot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZdrot", ("rocblas_zdrot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSrotg", ("rocblas_srotg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDrotg", ("rocblas_drotg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCrotg", ("rocblas_crotg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZrotg", ("rocblas_zrotg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSrotm", ("rocblas_srotm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDrotm", ("rocblas_drotm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSrotmg", ("rocblas_srotmg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDrotmg", ("rocblas_drotmg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSgemv", ("rocblas_sgemv", CONV_MATH_FUNC, API_BLAS)), + ("cublasSgemvBatched", ("rocblas_sgemv_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDgemv", ("rocblas_dgemv", CONV_MATH_FUNC, API_BLAS)), + ("cublasCgemv", ("rocblas_cgemv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZgemv", ("rocblas_zgemv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSgbmv", ("rocblas_sgbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDgbmv", ("rocblas_dgbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCgbmv", ("rocblas_cgbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZgbmv", ("rocblas_zgbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasStrmv", ("rocblas_strmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDtrmv", ("rocblas_dtrmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCtrmv", ("rocblas_ctrmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZtrmv", ("rocblas_ztrmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasStbmv", ("rocblas_stbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDtbmv", ("rocblas_dtbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCtbmv", ("rocblas_ctbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZtbmv", ("rocblas_ztbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasStpmv", ("rocblas_stpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDtpmv", ("rocblas_dtpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCtpmv", ("rocblas_ctpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZtpmv", ("rocblas_ztpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasStrsv", ("rocblas_strsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDtrsv", ("rocblas_dtrsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCtrsv", ("rocblas_ctrsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZtrsv", ("rocblas_ztrsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasStpsv", ("rocblas_stpsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDtpsv", ("rocblas_dtpsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCtpsv", ("rocblas_ctpsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZtpsv", ("rocblas_ztpsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasStbsv", ("rocblas_stbsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDtbsv", ("rocblas_dtbsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCtbsv", ("rocblas_ctbsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZtbsv", ("rocblas_ztbsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSsymv", ("rocblas_ssymv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDsymv", ("rocblas_dsymv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCsymv", ("rocblas_csymv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZsymv", ("rocblas_zsymv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasChemv", ("rocblas_chemv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZhemv", ("rocblas_zhemv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSsbmv", ("rocblas_ssbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDsbmv", ("rocblas_dsbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasChbmv", ("rocblas_chbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZhbmv", ("rocblas_zhbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSspmv", ("rocblas_sspmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDspmv", ("rocblas_dspmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasChpmv", ("rocblas_chpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZhpmv", ("rocblas_zhpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSger", ("rocblas_sger", CONV_MATH_FUNC, API_BLAS)), + ("cublasDger", ("rocblas_dger", CONV_MATH_FUNC, API_BLAS)), + ("cublasCgeru", ("rocblas_cgeru", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCgerc", ("rocblas_cgerc", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZgeru", ("rocblas_zgeru", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZgerc", ("rocblas_zgerc", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSsyr", ("rocblas_ssyr", CONV_MATH_FUNC, API_BLAS)), + ("cublasDsyr", ("rocblas_dsyr", CONV_MATH_FUNC, API_BLAS)), + ("cublasCher", ("rocblas_cher", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZher", ("rocblas_zher", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSspr", ("rocblas_sspr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDspr", ("rocblas_dspr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasChpr", ("rocblas_chpr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZhpr", ("rocblas_zhpr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSsyr2", ("rocblas_ssyr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDsyr2", ("rocblas_dsyr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCher2", ("rocblas_cher2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZher2", ("rocblas_zher2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSspr2", ("rocblas_sspr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDspr2", ("rocblas_dspr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasChpr2", ("rocblas_chpr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZhpr2", ("rocblas_zhpr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSgemm", ("rocblas_sgemm", CONV_MATH_FUNC, API_BLAS)), + ("cublasDgemm", ("rocblas_dgemm", CONV_MATH_FUNC, API_BLAS)), + ("cublasCgemm", ("rocblas_cgemm", CONV_MATH_FUNC, API_BLAS)), + ("cublasZgemm", ("rocblas_zgemm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasHgemm", ("rocblas_hgemm", CONV_MATH_FUNC, API_BLAS)), + ("cublasSgemmBatched", ("rocblas_sgemm_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDgemmBatched", ("rocblas_dgemm_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasHgemmBatched", ("rocblas_hgemm_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSgemmStridedBatched", ("rocblas_sgemm_strided_batched", CONV_MATH_FUNC, API_BLAS)), + ("cublasDgemmStridedBatched", ("rocblas_dgemm_strided_batched", CONV_MATH_FUNC, API_BLAS)), + ("cublasHgemmStridedBatched", ("rocblas_hgemm_strided_batched", CONV_MATH_FUNC, API_BLAS)), + ("cublasCgemmBatched", ("rocblas_cgemm_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCgemm3mBatched", ("rocblas_cgemm_3m_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZgemmBatched", ("rocblas_zgemm_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCgemmStridedBatched", ("rocblas_cgemm_strided_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCgemm3mStridedBatched", ("rocblas_cgemm_3m_strided_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZgemmStridedBatched", ("rocblas_zgemm_strided_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasHgemmStridedBatched", ("rocblas_hgemm_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSsyrk", ("rocblas_ssyrk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDsyrk", ("rocblas_dsyrk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCsyrk", ("rocblas_csyrk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZsyrk", ("rocblas_zsyrk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCherk", ("rocblas_cherk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZherk", ("rocblas_zherk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSsyr2k", ("rocblas_ssyr2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDsyr2k", ("rocblas_dsyr2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCsyr2k", ("rocblas_csyr2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZsyr2k", ("rocblas_zyr2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSsyrkx", ("rocblas_ssyrkx", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDsyrkx", ("rocblas_dsyrkx", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCsyrkx", ("rocblas_csyrkx", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZsyrkx", ("rocblas_zsyrkx", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCher2k", ("rocblas_cher2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZher2k", ("rocblas_zher2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCherkx", ("rocblas_cherkx", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZherkx", ("rocblas_zherkx", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSsymm", ("rocblas_ssymm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDsymm", ("rocblas_dsymm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCsymm", ("rocblas_csymm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZsymm", ("rocblas_zsymm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasChemm", ("rocblas_chemm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZhemm", ("rocblas_zhemm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasStrsm", ("rocblas_strsm", CONV_MATH_FUNC, API_BLAS)), + ("cublasDtrsm", ("rocblas_dtrsm", CONV_MATH_FUNC, API_BLAS)), + ("cublasCtrsm", ("rocblas_ctrsm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZtrsm", ("rocblas_ztrsm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasStrsmBatched", ("rocblas_strsm_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDtrsmBatched", ("rocblas_dtrsm_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCtrsmBatched", ("rocblas_ctrsm_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZtrsmBatched", ("rocblas_ztrsm_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasStrmm", ("rocblas_strmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDtrmm", ("rocblas_dtrmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCtrmm", ("rocblas_ctrmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZtrmm", ("rocblas_ztrmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSgeam", ("rocblas_sgeam", CONV_MATH_FUNC, API_BLAS)), + ("cublasDgeam", ("rocblas_dgeam", CONV_MATH_FUNC, API_BLAS)), + ("cublasCgeam", ("rocblas_cgeam", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZgeam", ("rocblas_zgeam", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSgetrfBatched", ("rocblas_sgetrf_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDgetrfBatched", ("rocblas_dgetrf_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCgetrfBatched", ("rocblas_cgetrf_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZgetrfBatched", ("rocblas_zgetrf_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSgetriBatched", ("rocblas_sgetri_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDgetriBatched", ("rocblas_dgetri_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCgetriBatched", ("rocblas_cgetri_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZgetriBatched", ("rocblas_zgetri_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSgetrsBatched", ("rocblas_sgetrs_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDgetrsBatched", ("rocblas_dgetrs_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCgetrsBatched", ("rocblas_cgetrs_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZgetrsBatched", ("rocblas_zgetrs_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasStrsmBatched", ("rocblas_strsm_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDtrsmBatched", ("rocblas_dtrsm_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCtrsmBatched", ("rocblas_ctrsm_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZtrsmBatched", ("rocblas_dtrsm_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSmatinvBatched", ("rocblas_smatinv_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDmatinvBatched", ("rocblas_dmatinv_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCmatinvBatched", ("rocblas_cmatinv_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZmatinvBatched", ("rocblas_zmatinv_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSgeqrfBatched", ("rocblas_sgeqrf_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDgeqrfBatched", ("rocblas_dgeqrf_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCgeqrfBatched", ("rocblas_cgeqrf_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZgeqrfBatched", ("rocblas_zgeqrf_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSgelsBatched", ("rocblas_sgels_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDgelsBatched", ("rocblas_dgels_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCgelsBatched", ("rocblas_cgels_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZgelsBatched", ("rocblas_zgels_batched", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSdgmm", ("rocblas_sdgmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDdgmm", ("rocblas_ddgmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCdgmm", ("rocblas_cdgmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZdgmm", ("rocblas_zdgmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasStpttr", ("rocblas_stpttr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDtpttr", ("rocblas_dtpttr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCtpttr", ("rocblas_ctpttr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZtpttr", ("rocblas_ztpttr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasStrttp", ("rocblas_strttp", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDtrttp", ("rocblas_dtrttp", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCtrttp", ("rocblas_ctrttp", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZtrttp", ("rocblas_ztrttp", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCreate_v2", ("rocblas_create_handle", CONV_MATH_FUNC, API_BLAS)), + ("cublasDestroy_v2", ("rocblas_destroy_handle", CONV_MATH_FUNC, API_BLAS)), + ("cublasGetVersion_v2", ("rocblas_get_version", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSetStream", ("rocblas_set_stream", CONV_MATH_FUNC, API_BLAS)), + ("cublasGetStream", ("rocblas_get_stream", CONV_MATH_FUNC, API_BLAS)), + ("cublasSetStream_v2", ("rocblas_set_stream", CONV_MATH_FUNC, API_BLAS)), + ("cublasGetStream_v2", ("rocblas_get_stream", CONV_MATH_FUNC, API_BLAS)), + ("cublasGetPointerMode_v2", ("rocblas_get_pointer_mode", CONV_MATH_FUNC, API_BLAS)), + ("cublasSetPointerMode_v2", ("rocblas_set_pointer_mode", CONV_MATH_FUNC, API_BLAS)), + ("cublasSgemv_v2", ("rocblas_sgemv", CONV_MATH_FUNC, API_BLAS)), + ("cublasDgemv_v2", ("rocblas_dgemv", CONV_MATH_FUNC, API_BLAS)), + ("cublasCgemv_v2", ("rocblas_cgemv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZgemv_v2", ("rocblas_zgemv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSgbmv_v2", ("rocblas_sgbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDgbmv_v2", ("rocblas_dgbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCgbmv_v2", ("rocblas_cgbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZgbmv_v2", ("rocblas_zgbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasStrmv_v2", ("rocblas_strmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDtrmv_v2", ("rocblas_dtrmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCtrmv_v2", ("rocblas_ctrmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZtrmv_v2", ("rocblas_ztrmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasStbmv_v2", ("rocblas_stbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDtbmv_v2", ("rocblas_dtbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCtbmv_v2", ("rocblas_ctbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZtbmv_v2", ("rocblas_ztbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasStpmv_v2", ("rocblas_stpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDtpmv_v2", ("rocblas_dtpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCtpmv_v2", ("rocblas_ctpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZtpmv_v2", ("rocblas_ztpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasStrsv_v2", ("rocblas_strsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDtrsv_v2", ("rocblas_dtrsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCtrsv_v2", ("rocblas_ctrsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZtrsv_v2", ("rocblas_ztrsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasStpsv_v2", ("rocblas_stpsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDtpsv_v2", ("rocblas_dtpsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCtpsv_v2", ("rocblas_ctpsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZtpsv_v2", ("rocblas_ztpsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasStbsv_v2", ("rocblas_stbsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDtbsv_v2", ("rocblas_dtbsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCtbsv_v2", ("rocblas_ctbsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZtbsv_v2", ("rocblas_ztbsv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSsymv_v2", ("rocblas_ssymv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDsymv_v2", ("rocblas_dsymv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCsymv_v2", ("rocblas_csymv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZsymv_v2", ("rocblas_zsymv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasChemv_v2", ("rocblas_chemv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZhemv_v2", ("rocblas_zhemv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSsbmv_v2", ("rocblas_ssbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDsbmv_v2", ("rocblas_dsbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasChbmv_v2", ("rocblas_chbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZhbmv_v2", ("rocblas_zhbmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSspmv_v2", ("rocblas_sspmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDspmv_v2", ("rocblas_dspmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasChpmv_v2", ("rocblas_chpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZhpmv_v2", ("rocblas_zhpmv", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSger_v2", ("rocblas_sger", CONV_MATH_FUNC, API_BLAS)), + ("cublasDger_v2", ("rocblas_dger", CONV_MATH_FUNC, API_BLAS)), + ("cublasCgeru_v2", ("rocblas_cgeru", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCgerc_v2", ("rocblas_cergc", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZgeru_v2", ("rocblas_zgeru", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZgerc_v2", ("rocblas_zgerc", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSsyr_v2", ("rocblas_ssyr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDsyr_v2", ("rocblas_dsyr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCsyr_v2", ("rocblas_csyr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZsyr_v2", ("rocblas_zsyr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCher_v2", ("rocblas_cher", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZher_v2", ("rocblas_zher", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSspr_v2", ("rocblas_sspr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDspr_v2", ("rocblas_dspr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasChpr_v2", ("rocblas_chpr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZhpr_v2", ("rocblas_zhpr", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSsyr2_v2", ("rocblas_ssyr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDsyr2_v2", ("rocblas_dsyr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCsyr2_v2", ("rocblas_csyr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZsyr2_v2", ("rocblas_zsyr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCher2_v2", ("rocblas_cher2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZher2_v2", ("rocblas_zher2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSspr2_v2", ("rocblas_sspr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDspr2_v2", ("rocblas_dspr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasChpr2_v2", ("rocblas_chpr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZhpr2_v2", ("rocblas_zhpr2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSgemm_v2", ("rocblas_sgemm", CONV_MATH_FUNC, API_BLAS)), + ("cublasDgemm_v2", ("rocblas_dgemm", CONV_MATH_FUNC, API_BLAS)), + ("cublasCgemm_v2", ("rocblas_cgemm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCgemm3m", ("rocblas_cgemm_3m", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCgemm3mEx", ("rocblas_cgemm_3mex", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZgemm_v2", ("rocblas_zgemm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZgemm3m", ("rocblas_zgemm_3m", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSgemmEx", ("rocblas_sgemmex", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasGemmEx", ("rocblas_gemmex", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCgemmEx", ("rocblas_cgemmex", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasUint8gemmBias", ("rocblas_uint8gemmbias", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSsyrk_v2", ("rocblas_ssyrk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDsyrk_v2", ("rocblas_dsyrk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCsyrk_v2", ("rocblas_csyrk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZsyrk_v2", ("rocblas_zsyrk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCsyrkEx", ("rocblas_csyrkex", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCsyrk3mEx", ("rocblas_csyrk3mex", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCherk_v2", ("rocblas_cherk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCherkEx", ("rocblas_cherkex", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCherk3mEx", ("rocblas_cherk3mex", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZherk_v2", ("rocblas_zherk", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSsyr2k_v2", ("rocblas_ssyr2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDsyr2k_v2", ("rocblas_dsyr2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCsyr2k_v2", ("rocblas_csyr2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZsyr2k_v2", ("rocblas_zsyr2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCher2k_v2", ("rocblas_cher2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZher2k_v2", ("rocblas_zher2k", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSsymm_v2", ("rocblas_ssymm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDsymm_v2", ("rocblas_dsymm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCsymm_v2", ("rocblas_csymm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZsymm_v2", ("rocblas_zsymm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasChemm_v2", ("rocblas_chemm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZhemm_v2", ("rocblas_zhemm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasStrsm_v2", ("rocblas_strsm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDtrsm_v2", ("rocblas_dtrsm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCtrsm_v2", ("rocblas_ctrsm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZtrsm_v2", ("rocblas_ztrsm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasStrmm_v2", ("rocblas_strmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDtrmm_v2", ("rocblas_dtrmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCtrmm_v2", ("rocblas_ctrmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZtrmm_v2", ("rocblas_ztrmm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSnrm2_v2", ("rocblas_snrm2", CONV_MATH_FUNC, API_BLAS)), + ("cublasDnrm2_v2", ("rocblas_dnrm2", CONV_MATH_FUNC, API_BLAS)), + ("cublasScnrm2_v2", ("rocblas_scnrm2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDznrm2_v2", ("rocblas_dznrm2", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDotEx", ("rocblas_dotex", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDotcEx", ("rocblas_dotcex", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSdot_v2", ("rocblas_sdot", CONV_MATH_FUNC, API_BLAS)), + ("cublasDdot_v2", ("rocblas_ddot", CONV_MATH_FUNC, API_BLAS)), + ("cublasCdotu_v2", ("rocblas_cdotu", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCdotc_v2", ("rocblas_cdotc", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZdotu_v2", ("rocblas_zdotu", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZdotc_v2", ("rocblas_zdotc", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasScalEx", ("rocblas_scalex", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSscal_v2", ("rocblas_sscal", CONV_MATH_FUNC, API_BLAS)), + ("cublasDscal_v2", ("rocblas_dscal", CONV_MATH_FUNC, API_BLAS)), + ("cublasCscal_v2", ("rocblas_cscal", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCsscal_v2", ("rocblas_csscal", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZscal_v2", ("rocblas_zcsal", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZdscal_v2", ("rocblas_zdscal", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasAxpyEx", ("rocblas_axpyex", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSaxpy_v2", ("rocblas_saxpy", CONV_MATH_FUNC, API_BLAS)), + ("cublasDaxpy_v2", ("rocblas_daxpy", CONV_MATH_FUNC, API_BLAS)), + ("cublasCaxpy_v2", ("rocblas_caxpy", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZaxpy_v2", ("rocblas_zaxpy", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasScopy_v2", ("rocblas_scopy", CONV_MATH_FUNC, API_BLAS)), + ("cublasDcopy_v2", ("rocblas_dcopy", CONV_MATH_FUNC, API_BLAS)), + ("cublasCcopy_v2", ("rocblas_ccopy", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZcopy_v2", ("rocblas_zcopy", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSswap_v2", ("rocblas_sswap", CONV_MATH_FUNC, API_BLAS)), + ("cublasDswap_v2", ("rocblas_dswap", CONV_MATH_FUNC, API_BLAS)), + ("cublasCswap_v2", ("rocblas_cswap", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZswap_v2", ("rocblas_zswap", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasIsamax_v2", ("rocblas_isamax", CONV_MATH_FUNC, API_BLAS)), + ("cublasIdamax_v2", ("rocblas_idamax", CONV_MATH_FUNC, API_BLAS)), + ("cublasIcamax_v2", ("rocblas_icamax", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasIzamax_v2", ("rocblas_izamax", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasIsamin_v2", ("rocblas_isamin", CONV_MATH_FUNC, API_BLAS)), + ("cublasIdamin_v2", ("rocblas_idamin", CONV_MATH_FUNC, API_BLAS)), + ("cublasIcamin_v2", ("rocblas_icamin", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasIzamin_v2", ("rocblas_izamin", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSasum_v2", ("rocblas_sasum", CONV_MATH_FUNC, API_BLAS)), + ("cublasDasum_v2", ("rocblas_dasum", CONV_MATH_FUNC, API_BLAS)), + ("cublasScasum_v2", ("rocblas_scasum", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDzasum_v2", ("rocblas_dzasum", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSrot_v2", ("rocblas_srot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDrot_v2", ("rocblas_drot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCrot_v2", ("rocblas_crot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCsrot_v2", ("rocblas_csrot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZrot_v2", ("rocblas_zrot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZdrot_v2", ("rocblas_zdrot", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSrotg_v2", ("rocblas_srotg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDrotg_v2", ("rocblas_drotg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasCrotg_v2", ("rocblas_crotg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasZrotg_v2", ("rocblas_zrotg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSrotm_v2", ("rocblas_srotm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDrotm_v2", ("rocblas_drotm", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasSrotmg_v2", ("rocblas_srotmg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("cublasDrotmg_v2", ("rocblas_drotmg", CONV_MATH_FUNC, API_BLAS, HIP_UNSUPPORTED)), + ("CURAND_STATUS_SUCCESS", ("HIPRAND_STATUS_SUCCESS", CONV_NUMERIC_LITERAL, API_RAND)), + ("curand_STATUS_VERSION_MISMATCH", ("HIPRAND_STATUS_VERSION_MISMATCH", CONV_NUMERIC_LITERAL, API_RAND)), + ("curand_STATUS_NOT_INITIALIZED", ("HIPRAND_STATUS_NOT_INITIALIZED", CONV_NUMERIC_LITERAL, API_RAND)), + ("curand_STATUS_ALLOCATION_FAILED", ("HIPRAND_STATUS_ALLOCATION_FAILED", CONV_NUMERIC_LITERAL, API_RAND)), + ("curand_STATUS_TYPE_ERROR", ("HIPRAND_STATUS_TYPE_ERROR", CONV_NUMERIC_LITERAL, API_RAND)), + ("curand_STATUS_OUT_OF_RANGE", ("HIPRAND_STATUS_OUT_OF_RANGE", CONV_NUMERIC_LITERAL, API_RAND)), + ("curand_STATUS_LENGTH_NOT_MULTIPLE", ("HIPRAND_STATUS_LENGTH_NOT_MULTIPLE", CONV_NUMERIC_LITERAL, API_RAND)), + ("curand_STATUS_DOUBLE_PRECISION_REQUIRED", ("HIPRAND_STATUS_DOUBLE_PRECISION_REQUIRED", CONV_NUMERIC_LITERAL, API_RAND)), + ("curand_STATUS_LAUNCH_FAILURE", ("HIPRAND_STATUS_LAUNCH_FAILURE", CONV_NUMERIC_LITERAL, API_RAND)), + ("curand_STATUS_PREEXISTING_FAILURE", ("HIPRAND_STATUS_PREEXISTING_FAILURE", CONV_NUMERIC_LITERAL, API_RAND)), + ("curand_STATUS_INITIALIZATION_FAILED", ("HIPRAND_STATUS_INITIALIZATION_FAILED", CONV_NUMERIC_LITERAL, API_RAND)), + ("curand_STATUS_ARCH_MISMATCH", ("HIPRAND_STATUS_ARCH_MISMATCH", CONV_NUMERIC_LITERAL, API_RAND)), + ("curand_STATUS_INTERNAL_ERROR", ("HIPRAND_STATUS_INTERNAL_ERROR", CONV_NUMERIC_LITERAL, API_RAND)), + ("curand_RNG_TEST", ("HIPRAND_RNG_TEST", CONV_NUMERIC_LITERAL, API_RAND)), + ("mtgp32dc_params_fast_11213", ("mtgp32dc_params_fast_11213", CONV_NUMERIC_LITERAL, API_RAND)), + ("curand_RNG_PSEUDO_DEFAULT", ("HIPRAND_RNG_PSEUDO_DEFAULT", CONV_NUMERIC_LITERAL, API_RAND)), + ("curand_RNG_PSEUDO_XORWOW", ("HIPRAND_RNG_PSEUDO_XORWOW", CONV_NUMERIC_LITERAL, API_RAND)), + ("curand_RNG_PSEUDO_MRG32K3A", ("HIPRAND_RNG_PSEUDO_MRG32K3A", CONV_NUMERIC_LITERAL, API_RAND)), + ("curand_RNG_PSEUDO_MTGP32", ("HIPRAND_RNG_PSEUDO_MTGP32", CONV_NUMERIC_LITERAL, API_RAND)), + ("curand_RNG_PSEUDO_MT19937", ("HIPRAND_RNG_PSEUDO_MT19937", CONV_NUMERIC_LITERAL, API_RAND)), + ("curand_RNG_PSEUDO_PHILOX4_32_10", ("HIPRAND_RNG_PSEUDO_PHILOX4_32_10", CONV_NUMERIC_LITERAL, API_RAND)), + ("curand_RNG_QUASI_DEFAULT", ("HIPRAND_RNG_QUASI_DEFAULT", CONV_NUMERIC_LITERAL, API_RAND)), + ("curand_RNG_QUASI_SOBOL32", ("HIPRAND_RNG_QUASI_SOBOL32", CONV_NUMERIC_LITERAL, API_RAND)), + ("curand_RNG_QUASI_SCRAMBLED_SOBOL32", ("HIPRAND_RNG_QUASI_SCRAMBLED_SOBOL32", CONV_NUMERIC_LITERAL, API_RAND)), + ("curand_RNG_QUASI_SOBOL64", ("HIPRAND_RNG_QUASI_SOBOL64", CONV_NUMERIC_LITERAL, API_RAND)), + ("curand_RNG_QUASI_SCRAMBLED_SOBOL64", ("HIPRAND_RNG_QUASI_SCRAMBLED_SOBOL64", CONV_NUMERIC_LITERAL, API_RAND)), + ("curand_ORDERING_PSEUDO_BEST", ("HIPRAND_ORDERING_PSEUDO_BEST", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED)), + ("curand_ORDERING_PSEUDO_DEFAULT", ("HIPRAND_ORDERING_PSEUDO_DEFAULT", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED)), + ("curand_ORDERING_PSEUDO_SEEDED", ("HIPRAND_ORDERING_PSEUDO_SEEDED", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED)), + ("curand_ORDERING_QUASI_DEFAULT", ("HIPRAND_ORDERING_QUASI_DEFAULT", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED)), + ("curand_DIRECTION_VECTORS_32_JOEKUO6", ("HIPRAND_DIRECTION_VECTORS_32_JOEKUO6", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED)), + ("curand_SCRAMBLED_DIRECTION_VECTORS_32_JOEKUO6", ("HIPRAND_SCRAMBLED_DIRECTION_VECTORS_32_JOEKUO6", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED)), + ("curand_DIRECTION_VECTORS_64_JOEKUO6", ("HIPRAND_DIRECTION_VECTORS_64_JOEKUO6", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED)), + ("curand_SCRAMBLED_DIRECTION_VECTORS_64_JOEKUO6", ("HIPRAND_SCRAMBLED_DIRECTION_VECTORS_64_JOEKUO6", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED)), + ("curand_CHOOSE_BEST", ("HIPRAND_CHOOSE_BEST", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED)), + ("curand_ITR", ("HIPRAND_ITR", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED)), + ("curand_KNUTH", ("HIPRAND_KNUTH", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED)), + ("curand_HITR", ("HIPRAND_HITR", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED)), + ("curand_M1", ("HIPRAND_M1", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED)), + ("curand_M2", ("HIPRAND_M2", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED)), + ("curand_BINARY_SEARCH", ("HIPRAND_BINARY_SEARCH", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED)), + ("curand_DISCRETE_GAUSS", ("HIPRAND_DISCRETE_GAUSS", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED)), + ("curand_REJECTION", ("HIPRAND_REJECTION", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED)), + ("curand_DEVICE_API", ("HIPRAND_DEVICE_API", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED)), + ("curand_FAST_REJECTION", ("HIPRAND_FAST_REJECTION", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED)), + ("curand_3RD", ("HIPRAND_3RD", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED)), + ("curand_DEFINITION", ("HIPRAND_DEFINITION", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED)), + ("curand_POISSON", ("HIPRAND_POISSON", CONV_NUMERIC_LITERAL, API_RAND, HIP_UNSUPPORTED)), + ("curandCreateGenerator", ("hiprandCreateGenerator", CONV_MATH_FUNC, API_RAND)), + ("curandCreateGeneratorHost", ("hiprandCreateGeneratorHost", CONV_MATH_FUNC, API_RAND)), + ("curandCreatePoissonDistribution", ("hiprandCreatePoissonDistribution", CONV_MATH_FUNC, API_RAND)), + ("curandDestroyDistribution", ("hiprandDestroyDistribution", CONV_MATH_FUNC, API_RAND)), + ("curandDestroyGenerator", ("hiprandDestroyGenerator", CONV_MATH_FUNC, API_RAND)), + ("curandGenerate", ("hiprandGenerate", CONV_MATH_FUNC, API_RAND)), + ("curandGenerateLogNormal", ("hiprandGenerateLogNormal", CONV_MATH_FUNC, API_RAND)), + ("curandGenerateLogNormalDouble", ("hiprandGenerateLogNormalDouble", CONV_MATH_FUNC, API_RAND)), + ("curandGenerateLongLong", ("hiprandGenerateLongLong", CONV_MATH_FUNC, API_RAND, HIP_UNSUPPORTED)), + ("curandGenerateNormal", ("hiprandGenerateNormal", CONV_MATH_FUNC, API_RAND)), + ("curandGenerateNormalDouble", ("hiprandGenerateNormalDouble", CONV_MATH_FUNC, API_RAND)), + ("curandGeneratePoisson", ("hiprandGeneratePoisson", CONV_MATH_FUNC, API_RAND)), + ("curandGenerateSeeds", ("hiprandGenerateSeeds", CONV_MATH_FUNC, API_RAND)), + ("curandGenerateUniform", ("hiprandGenerateUniform", CONV_MATH_FUNC, API_RAND)), + ("curandGenerateUniformDouble", ("hiprandGenerateUniformDouble", CONV_MATH_FUNC, API_RAND)), + ("curandGetDirectionVectors32", ("hiprandGetDirectionVectors32", CONV_MATH_FUNC, API_RAND, HIP_UNSUPPORTED)), + ("curandGetDirectionVectors64", ("hiprandGetDirectionVectors64", CONV_MATH_FUNC, API_RAND, HIP_UNSUPPORTED)), + ("curandGetProperty", ("hiprandGetProperty", CONV_MATH_FUNC, API_RAND, HIP_UNSUPPORTED)), + ("curandGetScrambleConstants32", ("hiprandGetScrambleConstants32", CONV_MATH_FUNC, API_RAND, HIP_UNSUPPORTED)), + ("curandGetScrambleConstants64", ("hiprandGetScrambleConstants64", CONV_MATH_FUNC, API_RAND, HIP_UNSUPPORTED)), + ("curandGetVersion", ("hiprandGetVersion", CONV_MATH_FUNC, API_RAND)), + ("curandSetGeneratorOffset", ("hiprandSetGeneratorOffset", CONV_MATH_FUNC, API_RAND)), + ("curandSetGeneratorOrdering", ("hiprandSetGeneratorOrdering", CONV_MATH_FUNC, API_RAND, HIP_UNSUPPORTED)), + ("curandSetPseudoRandomGeneratorSeed", ("hiprandSetPseudoRandomGeneratorSeed", CONV_MATH_FUNC, API_RAND)), + ("curandSetQuasiRandomGeneratorDimensions", ("hiprandSetQuasiRandomGeneratorDimensions", CONV_MATH_FUNC, API_RAND)), + ("curandSetStream", ("hiprandSetStream", CONV_MATH_FUNC, API_RAND)), + ("curand", ("hiprand", CONV_DEVICE_FUNC, API_RAND)), + ("curand_init", ("hiprand_init", CONV_DEVICE_FUNC, API_RAND)), + ("curand_log_normal", ("hiprand_log_normal", CONV_DEVICE_FUNC, API_RAND)), + ("curand_log_normal_double", ("hiprand_log_normal_double", CONV_DEVICE_FUNC, API_RAND)), + ("curand_log_normal2", ("hiprand_log_normal2", CONV_DEVICE_FUNC, API_RAND)), + ("curand_log_normal2_double", ("hiprand_log_normal2_double", CONV_DEVICE_FUNC, API_RAND)), + ("curand_log_normal4", ("hiprand_log_normal4", CONV_DEVICE_FUNC, API_RAND)), + ("curand_log_normal4_double", ("hiprand_log_normal4_double", CONV_DEVICE_FUNC, API_RAND)), + ("curand_mtgp32_single", ("hiprand_mtgp32_single", CONV_DEVICE_FUNC, API_RAND, HIP_UNSUPPORTED)), + ("curand_mtgp32_single_specific", ("hiprand_mtgp32_single_specific", CONV_DEVICE_FUNC, API_RAND, HIP_UNSUPPORTED)), + ("curand_mtgp32_specific", ("hiprand_mtgp32_specific", CONV_DEVICE_FUNC, API_RAND, HIP_UNSUPPORTED)), + ("curand_normal", ("hiprand_normal", CONV_DEVICE_FUNC, API_RAND)), + ("curandMakeMTGP32Constants", ("hiprandMakeMTGP32Constants", CONV_DEVICE_FUNC, API_RAND)), + ("curandMakeMTGP32KernelState", ("hiprandMakeMTGP32KernelState", CONV_DEVICE_FUNC, API_RAND)), + ("curand_normal_double", ("hiprand_normal_double", CONV_DEVICE_FUNC, API_RAND)), + ("curand_normal2", ("hiprand_normal2", CONV_DEVICE_FUNC, API_RAND)), + ("curand_normal2_double", ("hiprand_normal2_double", CONV_DEVICE_FUNC, API_RAND)), + ("curand_normal4", ("hiprand_normal4", CONV_DEVICE_FUNC, API_RAND)), + ("curand_normal4_double", ("hiprand_normal4_double", CONV_DEVICE_FUNC, API_RAND)), + ("curand_uniform", ("hiprand_uniform", CONV_DEVICE_FUNC, API_RAND)), + ("curand_uniform_double", ("hiprand_uniform_double", CONV_DEVICE_FUNC, API_RAND)), + ("curand_uniform2_double", ("hiprand_uniform2_double", CONV_DEVICE_FUNC, API_RAND)), + ("curand_uniform4", ("hiprand_uniform4", CONV_DEVICE_FUNC, API_RAND)), + ("curand_uniform4_double", ("hiprand_uniform4_double", CONV_DEVICE_FUNC, API_RAND)), + ("curand_discrete", ("hiprand_discrete", CONV_DEVICE_FUNC, API_RAND)), + ("curand_discrete4", ("hiprand_discrete4", CONV_DEVICE_FUNC, API_RAND)), + ("curand_poisson", ("hiprand_poisson", CONV_DEVICE_FUNC, API_RAND)), + ("curand_poisson4", ("hiprand_poisson4", CONV_DEVICE_FUNC, API_RAND)), + ("curand_Philox4x32_10", ("hiprand_Philox4x32_10", CONV_DEVICE_FUNC, API_RAND, HIP_UNSUPPORTED)), + ("mtgp32_kernel_params", ("mtgp32_kernel_params_t", CONV_MATH_FUNC, API_RAND)), + ("CUFFT_FORWARD", ("HIPFFT_FORWARD", CONV_NUMERIC_LITERAL, API_BLAS)), + ("CUFFT_INVERSE", ("HIPFFT_BACKWARD", CONV_NUMERIC_LITERAL, API_BLAS)), + ("CUFFT_COMPATIBILITY_DEFAULT", ("HIPFFT_COMPATIBILITY_DEFAULT", CONV_NUMERIC_LITERAL, API_BLAS, HIP_UNSUPPORTED)), + ("cufftResult_t", ("hipfftResult_t", CONV_TYPE, API_FFT)), + ("cufftResult", ("hipfftResult", CONV_TYPE, API_FFT)), + ("CUFFT_SUCCESS", ("HIPFFT_SUCCESS", CONV_NUMERIC_LITERAL, API_FFT)), + ("CUFFT_INVALID_PLAN", ("HIPFFT_INVALID_PLAN", CONV_NUMERIC_LITERAL, API_FFT)), + ("CUFFT_ALLOC_FAILED", ("HIPFFT_ALLOC_FAILED", CONV_NUMERIC_LITERAL, API_FFT)), + ("CUFFT_INVALID_TYPE", ("HIPFFT_INVALID_TYPE", CONV_NUMERIC_LITERAL, API_FFT)), + ("CUFFT_INVALID_VALUE", ("HIPFFT_INVALID_VALUE", CONV_NUMERIC_LITERAL, API_FFT)), + ("CUFFT_INTERNAL_ERROR", ("HIPFFT_INTERNAL_ERROR", CONV_NUMERIC_LITERAL, API_FFT)), + ("CUFFT_EXEC_FAILED", ("HIPFFT_EXEC_FAILED", CONV_NUMERIC_LITERAL, API_FFT)), + ("CUFFT_SETUP_FAILED", ("HIPFFT_SETUP_FAILED", CONV_NUMERIC_LITERAL, API_FFT)), + ("CUFFT_INVALID_SIZE", ("HIPFFT_INVALID_SIZE", CONV_NUMERIC_LITERAL, API_FFT)), + ("CUFFT_UNALIGNED_DATA", ("HIPFFT_UNALIGNED_DATA", CONV_NUMERIC_LITERAL, API_FFT)), + ("CUFFT_INCOMPLETE_PARAMETER_LIST", ("HIPFFT_INCOMPLETE_PARAMETER_LIST", CONV_NUMERIC_LITERAL, API_FFT)), + ("CUFFT_INVALID_DEVICE", ("HIPFFT_INVALID_DEVICE", CONV_NUMERIC_LITERAL, API_FFT)), + ("CUFFT_PARSE_ERROR", ("HIPFFT_PARSE_ERROR", CONV_NUMERIC_LITERAL, API_FFT)), + ("CUFFT_NO_WORKSPACE", ("HIPFFT_NO_WORKSPACE", CONV_NUMERIC_LITERAL, API_FFT)), + ("CUFFT_NOT_IMPLEMENTED", ("HIPFFT_NOT_IMPLEMENTED", CONV_NUMERIC_LITERAL, API_FFT)), + ("CUFFT_LICENSE_ERROR", ("HIPFFT_LICENSE_ERROR", CONV_NUMERIC_LITERAL, API_FFT, HIP_UNSUPPORTED)), + ("CUFFT_NOT_SUPPORTED", ("HIPFFT_NOT_SUPPORTED", CONV_NUMERIC_LITERAL, API_FFT)), + ("cufftType_t", ("hipfftType_t", CONV_TYPE, API_FFT)), + ("cufftType", ("hipfftType", CONV_TYPE, API_FFT)), + ("CUFFT_R2C", ("HIPFFT_R2C", CONV_NUMERIC_LITERAL, API_FFT)), + ("CUFFT_C2R", ("HIPFFT_C2R", CONV_NUMERIC_LITERAL, API_FFT)), + ("CUFFT_C2C", ("HIPFFT_C2C", CONV_NUMERIC_LITERAL, API_FFT)), + ("CUFFT_D2Z", ("HIPFFT_D2Z", CONV_NUMERIC_LITERAL, API_FFT)), + ("CUFFT_Z2D", ("HIPFFT_Z2D", CONV_NUMERIC_LITERAL, API_FFT)), + ("CUFFT_Z2Z", ("HIPFFT_Z2Z", CONV_NUMERIC_LITERAL, API_FFT)), + ("cufftCompatibility_t", ("hipfftCompatibility_t", CONV_TYPE, API_FFT, HIP_UNSUPPORTED)), + ("cufftCompatibility", ("hipfftCompatibility", CONV_TYPE, API_FFT, HIP_UNSUPPORTED)), + ("CUFFT_COMPATIBILITY_FFTW_PADDING", ("HIPFFT_COMPATIBILITY_FFTW_PADDING", CONV_NUMERIC_LITERAL, API_FFT, HIP_UNSUPPORTED)), + ("cufftReal", ("hipfftReal", CONV_TYPE, API_FFT)), + ("cufftDoubleReal", ("hipfftDoubleReal", CONV_TYPE, API_FFT)), + ("cufftComplex", ("hipfftComplex", CONV_TYPE, API_FFT)), + ("cufftDoubleComplex", ("hipfftDoubleComplex", CONV_TYPE, API_FFT)), + ("cufftHandle", ("hipfftHandle", CONV_TYPE, API_FFT)), + ("cufftPlan1d", ("hipfftPlan1d", CONV_MATH_FUNC, API_FFT)), + ("cufftPlan2d", ("hipfftPlan2d", CONV_MATH_FUNC, API_FFT)), + ("cufftPlan3d", ("hipfftPlan3d", CONV_MATH_FUNC, API_FFT)), + ("cufftPlanMany", ("hipfftPlanMany", CONV_MATH_FUNC, API_FFT)), + ("cufftMakePlan1d", ("hipfftMakePlan1d", CONV_MATH_FUNC, API_FFT)), + ("cufftMakePlan2d", ("hipfftMakePlan2d", CONV_MATH_FUNC, API_FFT)), + ("cufftMakePlan3d", ("hipfftMakePlan3d", CONV_MATH_FUNC, API_FFT)), + ("cufftMakePlanMany", ("hipfftMakePlanMany", CONV_MATH_FUNC, API_FFT)), + ("cufftMakePlanMany64", ("hipfftMakePlanMany64", CONV_MATH_FUNC, API_FFT)), + ("cufftGetSizeMany64", ("hipfftGetSizeMany64", CONV_MATH_FUNC, API_FFT)), + ("cufftEstimate1d", ("hipfftEstimate1d", CONV_MATH_FUNC, API_FFT)), + ("cufftEstimate2d", ("hipfftEstimate2d", CONV_MATH_FUNC, API_FFT)), + ("cufftEstimate3d", ("hipfftEstimate3d", CONV_MATH_FUNC, API_FFT)), + ("cufftEstimateMany", ("hipfftEstimateMany", CONV_MATH_FUNC, API_FFT)), + ("cufftCreate", ("hipfftCreate", CONV_MATH_FUNC, API_FFT)), + ("cufftGetSize1d", ("hipfftGetSize1d", CONV_MATH_FUNC, API_FFT)), + ("cufftGetSize2d", ("hipfftGetSize2d", CONV_MATH_FUNC, API_FFT)), + ("cufftGetSize3d", ("hipfftGetSize3d", CONV_MATH_FUNC, API_FFT)), + ("cufftGetSizeMany", ("hipfftGetSizeMany", CONV_MATH_FUNC, API_FFT)), + ("cufftGetSize", ("hipfftGetSize", CONV_MATH_FUNC, API_FFT)), + ("cufftSetWorkArea", ("hipfftSetWorkArea", CONV_MATH_FUNC, API_FFT)), + ("cufftSetAutoAllocation", ("hipfftSetAutoAllocation", CONV_MATH_FUNC, API_FFT)), + ("cufftExecC2C", ("hipfftExecC2C", CONV_MATH_FUNC, API_FFT)), + ("cufftExecR2C", ("hipfftExecR2C", CONV_MATH_FUNC, API_FFT)), + ("cufftExecC2R", ("hipfftExecC2R", CONV_MATH_FUNC, API_FFT)), + ("cufftExecZ2Z", ("hipfftExecZ2Z", CONV_MATH_FUNC, API_FFT)), + ("cufftExecD2Z", ("hipfftExecD2Z", CONV_MATH_FUNC, API_FFT)), + ("cufftExecZ2D", ("hipfftExecZ2D", CONV_MATH_FUNC, API_FFT)), + ("cufftSetStream", ("hipfftSetStream", CONV_MATH_FUNC, API_FFT)), + ("cufftDestroy", ("hipfftDestroy", CONV_MATH_FUNC, API_FFT)), + ("cufftGetVersion", ("hipfftGetVersion", CONV_MATH_FUNC, API_FFT)), + ("cufftGetProperty", ("hipfftGetProperty", CONV_MATH_FUNC, API_FFT, HIP_UNSUPPORTED)), +]) -CUDA_SPARSE_MAP = { - "cusparseStatus_t": ("hipsparseStatus_t", CONV_MATH_FUNC, API_SPARSE), - "cusparseHandle_t": ("hipsparseHandle_t", CONV_MATH_FUNC, API_SPARSE), - "cusparseOperation_t": ("hipsparseOperation_t", CONV_TYPE, API_SPARSE), - "cusparseCreate": ("hipsparseCreate", CONV_MATH_FUNC, API_SPARSE), - "cusparseDestroy": ("hipsparseDestroy", CONV_MATH_FUNC, API_SPARSE), - "cusparseXcoo2csr": ("hipsparseXcoo2csr", CONV_MATH_FUNC, API_SPARSE), - "cusparseMatDescr_t": ("hipsparseMatDescr_t", CONV_MATH_FUNC, API_SPARSE), - "cusparseCreateMatDescr": ("hipsparseCreateMatDescr", CONV_MATH_FUNC, API_SPARSE), - "cusparseScsrmm2": ("hipsparseScsrmm2", CONV_MATH_FUNC, API_SPARSE), - "cusparseDcsrmm2": ("hipsparseDcsrmm2", CONV_MATH_FUNC, API_SPARSE), - "cusparseXcsrsort_bufferSizeExt": ("hipsparseXcsrsort_bufferSizeExt", CONV_MATH_FUNC, API_SPARSE), - "cusparseXcsrsort": ("hipsparseXcsrsort", CONV_MATH_FUNC, API_SPARSE), - "cusparseXcoosort_bufferSizeExt": ("hipsparseXcoosort_bufferSizeExt", CONV_MATH_FUNC, API_SPARSE), - "cusparseXcoosortByRow": ("hipsparseXcoosortByRow", CONV_MATH_FUNC, API_SPARSE), - "cusparseSetStream": ("hipsparseSetStream", CONV_MATH_FUNC, API_SPARSE), - "cusparseCreateIdentityPermutation": ("hipsparseCreateIdentityPermutation", CONV_MATH_FUNC, API_SPARSE), - "cusparseSetMatIndexBase": ("hipsparseSetMatIndexBase", CONV_MATH_FUNC, API_SPARSE), - "CUSPARSE_STATUS_SUCCESS": ("HIPSPARSE_STATUS_SUCCESS", CONV_NUMERIC_LITERAL, API_SPARSE), - "CUSPARSE_STATUS_NOT_INITIALIZED": ("HIPSPARSE_STATUS_NOT_INITIALIZED", CONV_NUMERIC_LITERAL, API_SPARSE), - "CUSPARSE_STATUS_ALLOC_FAILED": ("HIPSPARSE_STATUS_ALLOC_FAILED", CONV_NUMERIC_LITERAL, API_SPARSE), - "CUSPARSE_STATUS_INVALID_VALUE": ("HIPSPARSE_STATUS_INVALID_VALUE", CONV_NUMERIC_LITERAL, API_SPARSE), - "CUSPARSE_STATUS_MAPPING_ERROR": ("HIPSPARSE_STATUS_MAPPING_ERROR", CONV_NUMERIC_LITERAL, API_SPARSE), - "CUSPARSE_STATUS_EXECUTION_FAILED": ("HIPSPARSE_STATUS_EXECUTION_FAILED", CONV_NUMERIC_LITERAL, API_SPARSE), - "CUSPARSE_STATUS_INTERNAL_ERROR": ("HIPSPARSE_STATUS_INTERNAL_ERROR", CONV_NUMERIC_LITERAL, API_SPARSE), - "CUSPARSE_STATUS_MATRIX_TYPE_NOT_SUPPORTED": ("HIPSPARSE_STATUS_MATRIX_TYPE_NOT_SUPPORTED", CONV_NUMERIC_LITERAL, API_SPARSE), - "CUSPARSE_STATUS_ARCH_MISMATCH": ("HIPSPARSE_STATUS_ARCH_MISMATCH", CONV_NUMERIC_LITERAL, API_SPARSE), - "CUSPARSE_STATUS_ZERO_PIVOT": ("HIPSPARSE_STATUS_ZERO_PIVOT", CONV_NUMERIC_LITERAL, API_SPARSE), - "CUSPARSE_OPERATION_TRANSPOSE": ("HIPSPARSE_OPERATION_TRANSPOSE", CONV_NUMERIC_LITERAL, API_SPARSE), - "CUSPARSE_OPERATION_NON_TRANSPOSE": ("HIPSPARSE_OPERATION_NON_TRANSPOSE", CONV_NUMERIC_LITERAL, API_SPARSE), - "CUSPARSE_OPERATION_CONJUGATE_TRANSPOSE": ("HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE", CONV_NUMERIC_LITERAL, API_SPARSE), - "CUSPARSE_INDEX_BASE_ZERO": ("HIPSPARSE_INDEX_BASE_ZERO", CONV_NUMERIC_LITERAL, API_SPARSE), - "CUSPARSE_INDEX_BASE_ONE": ("HIPSPARSE_INDEX_BASE_ONE", CONV_NUMERIC_LITERAL, API_SPARSE), -} +CUDA_SPARSE_MAP = collections.OrderedDict([ + ("cusparseStatus_t", ("hipsparseStatus_t", CONV_MATH_FUNC, API_SPARSE)), + ("cusparseHandle_t", ("hipsparseHandle_t", CONV_MATH_FUNC, API_SPARSE)), + ("cusparseOperation_t", ("hipsparseOperation_t", CONV_TYPE, API_SPARSE)), + ("cusparseCreate", ("hipsparseCreate", CONV_MATH_FUNC, API_SPARSE)), + ("cusparseDestroy", ("hipsparseDestroy", CONV_MATH_FUNC, API_SPARSE)), + ("cusparseXcoo2csr", ("hipsparseXcoo2csr", CONV_MATH_FUNC, API_SPARSE)), + ("cusparseMatDescr_t", ("hipsparseMatDescr_t", CONV_MATH_FUNC, API_SPARSE)), + ("cusparseCreateMatDescr", ("hipsparseCreateMatDescr", CONV_MATH_FUNC, API_SPARSE)), + ("cusparseScsrmm2", ("hipsparseScsrmm2", CONV_MATH_FUNC, API_SPARSE)), + ("cusparseDcsrmm2", ("hipsparseDcsrmm2", CONV_MATH_FUNC, API_SPARSE)), + ("cusparseXcsrsort_bufferSizeExt", ("hipsparseXcsrsort_bufferSizeExt", CONV_MATH_FUNC, API_SPARSE)), + ("cusparseXcsrsort", ("hipsparseXcsrsort", CONV_MATH_FUNC, API_SPARSE)), + ("cusparseXcoosort_bufferSizeExt", ("hipsparseXcoosort_bufferSizeExt", CONV_MATH_FUNC, API_SPARSE)), + ("cusparseXcoosortByRow", ("hipsparseXcoosortByRow", CONV_MATH_FUNC, API_SPARSE)), + ("cusparseSetStream", ("hipsparseSetStream", CONV_MATH_FUNC, API_SPARSE)), + ("cusparseCreateIdentityPermutation", ("hipsparseCreateIdentityPermutation", CONV_MATH_FUNC, API_SPARSE)), + ("cusparseSetMatIndexBase", ("hipsparseSetMatIndexBase", CONV_MATH_FUNC, API_SPARSE)), + ("CUSPARSE_STATUS_SUCCESS", ("HIPSPARSE_STATUS_SUCCESS", CONV_NUMERIC_LITERAL, API_SPARSE)), + ("CUSPARSE_STATUS_NOT_INITIALIZED", ("HIPSPARSE_STATUS_NOT_INITIALIZED", CONV_NUMERIC_LITERAL, API_SPARSE)), + ("CUSPARSE_STATUS_ALLOC_FAILED", ("HIPSPARSE_STATUS_ALLOC_FAILED", CONV_NUMERIC_LITERAL, API_SPARSE)), + ("CUSPARSE_STATUS_INVALID_VALUE", ("HIPSPARSE_STATUS_INVALID_VALUE", CONV_NUMERIC_LITERAL, API_SPARSE)), + ("CUSPARSE_STATUS_MAPPING_ERROR", ("HIPSPARSE_STATUS_MAPPING_ERROR", CONV_NUMERIC_LITERAL, API_SPARSE)), + ("CUSPARSE_STATUS_EXECUTION_FAILED", ("HIPSPARSE_STATUS_EXECUTION_FAILED", CONV_NUMERIC_LITERAL, API_SPARSE)), + ("CUSPARSE_STATUS_INTERNAL_ERROR", ("HIPSPARSE_STATUS_INTERNAL_ERROR", CONV_NUMERIC_LITERAL, API_SPARSE)), + ("CUSPARSE_STATUS_MATRIX_TYPE_NOT_SUPPORTED", ("HIPSPARSE_STATUS_MATRIX_TYPE_NOT_SUPPORTED", CONV_NUMERIC_LITERAL, API_SPARSE)), + ("CUSPARSE_STATUS_ARCH_MISMATCH", ("HIPSPARSE_STATUS_ARCH_MISMATCH", CONV_NUMERIC_LITERAL, API_SPARSE)), + ("CUSPARSE_STATUS_ZERO_PIVOT", ("HIPSPARSE_STATUS_ZERO_PIVOT", CONV_NUMERIC_LITERAL, API_SPARSE)), + ("CUSPARSE_OPERATION_TRANSPOSE", ("HIPSPARSE_OPERATION_TRANSPOSE", CONV_NUMERIC_LITERAL, API_SPARSE)), + ("CUSPARSE_OPERATION_NON_TRANSPOSE", ("HIPSPARSE_OPERATION_NON_TRANSPOSE", CONV_NUMERIC_LITERAL, API_SPARSE)), + ("CUSPARSE_OPERATION_CONJUGATE_TRANSPOSE", ("HIPSPARSE_OPERATION_CONJUGATE_TRANSPOSE", CONV_NUMERIC_LITERAL, API_SPARSE)), + ("CUSPARSE_INDEX_BASE_ZERO", ("HIPSPARSE_INDEX_BASE_ZERO", CONV_NUMERIC_LITERAL, API_SPARSE)), + ("CUSPARSE_INDEX_BASE_ONE", ("HIPSPARSE_INDEX_BASE_ONE", CONV_NUMERIC_LITERAL, API_SPARSE)), +]) -PYTORCH_SPECIFIC_MAPPINGS = { - "cudaHostAllocator": ("hipHostAllocator", API_PYTORCH), - "cudaDeviceAllocator": ("hipDeviceAllocator", API_PYTORCH), - "define MAX_NUM_BLOCKS 200": ("define MAX_NUM_BLOCKS 64", API_PYTORCH), -} +PYTORCH_SPECIFIC_MAPPINGS = collections.OrderedDict([ + ("cudaHostAllocator", ("hipHostAllocator", API_PYTORCH)), + ("cudaDeviceAllocator", ("hipDeviceAllocator", API_PYTORCH)), + ("define MAX_NUM_BLOCKS 200", ("define MAX_NUM_BLOCKS 64", API_PYTORCH)), +]) -CAFFE2_SPECIFIC_MAPPINGS = { - "CUDA" :("HIP", API_CAFFE2), - "Cuda" :("Hip", API_CAFFE2), - "cuda_" :("hip_", API_CAFFE2), - "CUDNN" :("MIOPEN", API_CAFFE2), - "REGISTER_CUDA_OPERATOR" : ("REGISTER_HIP_OPERATOR", API_CAFFE2), - "cuda_stream" : ("hip_stream", API_CAFFE2), - "context_gpu" : ("hip/context_hip", API_CAFFE2), - "common_gpu" : ("hip/common_hip", API_CAFFE2), - "mixed_utils" : ("hip/mixed_utils_hip", API_CAFFE2), - "operator_fallback_gpu" : ("hip/operator_fallback_hip", API_CAFFE2), - "spatial_batch_norm_op_gpu_impl" : ("hip/spatial_batch_norm_op_hip_impl", API_CAFFE2), - "recurrent_network_executor_gpu" : ("hip/recurrent_network_executor_hip", API_CAFFE2), - "max_pool_with_index_gpu": ("hip/max_pool_with_index_hip", API_CAFFE2), - "THCCachingAllocator_gpu": ("hip/THCCachingAllocator_hip", API_CAFFE2), - "CUDA_1D_KERNEL_LOOP" : ("HIP_1D_KERNEL_LOOP", API_CAFFE2), - "CUDAContext" : ("HIPContext", API_CAFFE2), - "CAFFE_CUDA_NUM_THREADS" : ("CAFFE_HIP_NUM_THREADS", API_CAFFE2), - "HasCudaGPU" : ("HasHipGPU", API_CAFFE2), - "__expf" : ("expf", API_CAFFE2), - "CUBLAS_ENFORCE" : ("ROCBLAS_ENFORCE", API_CAFFE2), - "cublas_handle" : ("rocblas_handle", API_CAFFE2), - "CURAND_ENFORCE" :("HIPRAND_ENFORCE", API_CAFFE2), - "curandGenerateUniform" : ("hiprandGenerateUniform", API_CAFFE2), - "curand_generator" : ("hiprand_generator", API_CAFFE2), - "cuda_gpu_id" : ("hip_gpu_id", API_CAFFE2), - "CaffeCudaGetDevice" : ("CaffeHipGetDevice", API_CAFFE2), -} +CAFFE2_SPECIFIC_MAPPINGS = collections.OrderedDict([ + ("CUDA" ,("HIP", API_CAFFE2)), + ("Cuda" ,("Hip", API_CAFFE2)), + ("cuda_" ,("hip_", API_CAFFE2)), + ("CUDNN" ,("MIOPEN", API_CAFFE2)), + ("REGISTER_CUDA_OPERATOR" , ("REGISTER_HIP_OPERATOR", API_CAFFE2)), + ("cuda_stream" , ("hip_stream", API_CAFFE2)), + ("context_gpu" , ("hip/context_hip", API_CAFFE2)), + ("common_gpu" , ("hip/common_hip", API_CAFFE2)), + ("mixed_utils" , ("hip/mixed_utils_hip", API_CAFFE2)), + ("operator_fallback_gpu" , ("hip/operator_fallback_hip", API_CAFFE2)), + ("spatial_batch_norm_op_gpu_impl" , ("hip/spatial_batch_norm_op_hip_impl", API_CAFFE2)), + ("recurrent_network_executor_gpu" , ("hip/recurrent_network_executor_hip", API_CAFFE2)), + ("max_pool_with_index_gpu", ("hip/max_pool_with_index_hip", API_CAFFE2)), + ("THCCachingAllocator_gpu", ("hip/THCCachingAllocator_hip", API_CAFFE2)), + ("CUDA_1D_KERNEL_LOOP" , ("HIP_1D_KERNEL_LOOP", API_CAFFE2)), + ("CUDAContext" , ("HIPContext", API_CAFFE2)), + ("CAFFE_CUDA_NUM_THREADS" , ("CAFFE_HIP_NUM_THREADS", API_CAFFE2)), + ("HasCudaGPU" , ("HasHipGPU", API_CAFFE2)), + ("__expf" , ("expf", API_CAFFE2)), + ("CUBLAS_ENFORCE" , ("ROCBLAS_ENFORCE", API_CAFFE2)), + ("cublas_handle" , ("rocblas_handle", API_CAFFE2)), + ("CURAND_ENFORCE" ,("HIPRAND_ENFORCE", API_CAFFE2)), + ("curandGenerateUniform" , ("hiprandGenerateUniform", API_CAFFE2)), + ("curand_generator" , ("hiprand_generator", API_CAFFE2)), + ("cuda_gpu_id" , ("hip_gpu_id", API_CAFFE2)), + ("CaffeCudaGetDevice" , ("CaffeHipGetDevice", API_CAFFE2)), +]) CUDA_TO_HIP_MAPPINGS = [CUDA_IDENTIFIER_MAP, CUDA_TYPE_NAME_MAP, CUDA_INCLUDE_MAP, CUDA_SPARSE_MAP, PYTORCH_SPECIFIC_MAPPINGS, CAFFE2_SPECIFIC_MAPPINGS] diff --git a/tools/amd_build/pyHIPIFY/hipify-python.py b/tools/amd_build/pyHIPIFY/hipify-python.py index 288809f43f5282..e07b57c002acdd 100755 --- a/tools/amd_build/pyHIPIFY/hipify-python.py +++ b/tools/amd_build/pyHIPIFY/hipify-python.py @@ -32,7 +32,6 @@ import sys import os import yaml -import ast from functools import reduce from enum import Enum diff --git a/tools/autograd/templates/Functions.cpp b/tools/autograd/templates/Functions.cpp index f30701a4065176..3eaa5426736087 100644 --- a/tools/autograd/templates/Functions.cpp +++ b/tools/autograd/templates/Functions.cpp @@ -1,3 +1,10 @@ +// NB: Must be at the top of file to avoid including the deprecated "math.h". +// https://stackoverflow.com/questions/6563810/m-pi-works-with-math-h-but-not-with-cmath-in-visual-studio +#ifdef _MSC_VER +#define _USE_MATH_DEFINES +#include +#endif + #include "Functions.h" #include #include @@ -6,12 +13,7 @@ #include #include -// define constants like M_PI and C keywords for MSVC -#ifdef _MSC_VER -#define _USE_MATH_DEFINES #include -#endif -#include #include #include diff --git a/tools/build_pytorch_libs.bat b/tools/build_pytorch_libs.bat index c924b593efc23f..fc77bae0f80777 100755 --- a/tools/build_pytorch_libs.bat +++ b/tools/build_pytorch_libs.bat @@ -201,7 +201,6 @@ goto:eof -DMKLDNN_LIBRARY="%MKLDNN_LIBRARY%" ^ -DATEN_NO_CONTRIB=1 ^ -DCMAKE_INSTALL_PREFIX="%INSTALL_DIR%" ^ - -DCMAKE_EXPORT_COMPILE_COMMANDS=1 ^ -DCMAKE_C_FLAGS="%USER_CFLAGS%" ^ -DCMAKE_CXX_FLAGS="/EHa %USER_CFLAGS%" ^ -DCMAKE_EXE_LINKER_FLAGS="%USER_LDFLAGS%" ^ diff --git a/tools/build_pytorch_libs.sh b/tools/build_pytorch_libs.sh index 184c60b7c444f2..bab67cee81a069 100755 --- a/tools/build_pytorch_libs.sh +++ b/tools/build_pytorch_libs.sh @@ -197,7 +197,7 @@ function build() { -DCMAKE_DEBUG_POSTFIX="" \ -DCMAKE_BUILD_TYPE=$BUILD_TYPE \ ${@:2} \ - -DCMAKE_EXPORT_COMPILE_COMMANDS=1 ${CMAKE_ARGS[@]} + ${CMAKE_ARGS[@]} fi ${CMAKE_INSTALL} -j"$MAX_JOBS" popd @@ -301,7 +301,6 @@ function build_caffe2() { -DMKLDNN_LIB_DIR=$MKLDNN_LIB_DIR \ -DMKLDNN_LIBRARY=$MKLDNN_LIBRARY \ -DCMAKE_INSTALL_PREFIX="$INSTALL_DIR" \ - -DCMAKE_EXPORT_COMPILE_COMMANDS=1 \ -DCMAKE_C_FLAGS="$USER_CFLAGS" \ -DCMAKE_CXX_FLAGS="$USER_CFLAGS" \ -DCMAKE_EXE_LINKER_FLAGS="$LDFLAGS $USER_LDFLAGS" \ diff --git a/tools/clang_tidy.py b/tools/clang_tidy.py index 22c2accb6be6c7..740ec30877a7f0 100644 --- a/tools/clang_tidy.py +++ b/tools/clang_tidy.py @@ -1,111 +1,91 @@ #!/usr/bin/env python +""" +A driver script to run clang-tidy on changes detected via git. + +By default, clang-tidy runs on all files you point it at. This means that even +if you changed only parts of that file, you will get warnings for the whole +file. This script has the ability to ask git for the exact lines that have +changed since a particular git revision, and makes clang-tidy only lint those. +This makes it much less overhead to integrate in CI and much more relevant to +developers. This git-enabled mode is optional, and full scans of a directory +tree are also possible. In both cases, the script allows filtering files via +glob or regular expressions. +""" import argparse +import fnmatch import json import os.path import re +import shlex import subprocess import sys -DEFAULT_FILE_PATTERN = r".*\.[ch](pp)?" +# NOTE: Clang-tidy cannot lint headers directly, because headers are not +# compiled -- translation units are, of which there is one per implementation +# (c/cc/cpp) file. +DEFAULT_FILE_PATTERN = re.compile(r".*\.c(c|pp)?") # @@ -start,count +start,count @@ CHUNK_PATTERN = r"^@@\s+-\d+,\d+\s+\+(\d+)(?:,(\d+))?\s+@@" +# Set from command line arguments in main(). +VERBOSE = False -def run_shell_command(arguments, process_name=None): - """Executes a shell command.""" - assert len(arguments) > 0 - try: - output = subprocess.check_output(arguments, stderr=subprocess.STDOUT) - except OSError: - _, e, _ = sys.exc_info() - process_name = process_name or arguments[0] - raise RuntimeError("Error executing {}: {}".format(process_name, e)) - else: - return output.decode() - - -def normalize_directory_path(path): - """Normalizes a directory path.""" - return path.rstrip('/') +def run_shell_command(arguments): + """Executes a shell command.""" + if VERBOSE: + print(" ".join(arguments)) + result = subprocess.run(arguments, stdout=subprocess.PIPE) + output = result.stdout.decode().strip() + if result.returncode != 0: + raise RuntimeError("Error executing {}: {}".format(" ".join(arguments), output)) -def transform_globs_into_regexes(globs): - """Turns glob patterns into regular expressions.""" - return [glob.replace("*", ".*").replace("?", ".") for glob in globs] + return output def get_file_patterns(globs, regexes): """Returns a list of compiled regex objects from globs and regex pattern strings.""" - regexes += transform_globs_into_regexes(globs) - if not regexes: - regexes = [DEFAULT_FILE_PATTERN] - return [re.compile(regex + "$") for regex in regexes] - + # fnmatch.translate converts a glob into a regular expression. + # https://docs.python.org/2/library/fnmatch.html#fnmatch.translate + regexes += [fnmatch.translate(glob) for glob in globs] + return [re.compile(regex) for regex in regexes] or [DEFAULT_FILE_PATTERN] -def git_diff(args, verbose): - """Executes a git diff command in the shell and returns its output.""" - # --no-pager gets us the plain output, without pagination. - # --no-color removes color codes. - command = ["git", "--no-pager", "diff", "--no-color"] + args - if verbose: - print(" ".join(command)) - return run_shell_command(command, process_name="git diff") - -def filter_files(files, file_patterns, verbose): +def filter_files(files, file_patterns): """Returns all files that match any of the patterns.""" - filtered = [] for file in files: has_match = False for pattern in file_patterns: - if pattern.search(file): - filtered.append(file) + if pattern.match(file): + yield file has_match = True - if not has_match and verbose: - message = "{} does not match any ".format(file) - message += "file pattern in {{{}}}".format(', '.join(map(str, file_patterns))) - print(message) - return filtered - + if not has_match and VERBOSE: + message = "{} does not match any file pattern in {{{}}}" + print(message.format(file, ", ".join(map(str, file_patterns)))) -def remove_recursive_files(files, paths, verbose): - """ - Removes all files that are not immediately under one of the given paths. - """ - for file in files: - if os.path.dirname(file) in paths: - yield file - else: - if verbose: - - message = "{} ({}) does not match any ".format(file, os.path.dirname(file)) - message += "non-recursive path in {{{}}}".format(", ".join(paths)) - print(message) - -def get_changed_files(revision, paths, verbose): +def get_changed_files(revision, paths): """Runs git diff to get the paths of all changed files.""" # --diff-filter AMU gets us files that are (A)dded, (M)odified or (U)nmerged (in the working copy). # --name-only makes git diff return only the file paths, without any of the source changes. - args = ["--diff-filter", "AMU", "--ignore-all-space", "--name-only", revision] - output = git_diff(args + paths, verbose) + command = "git diff-index --diff-filter=AMU --ignore-all-space --name-only" + output = run_shell_command(shlex.split(command) + [revision] + paths) return output.split("\n") def get_all_files(paths): - """Yields all files in any of the given paths""" - for path in paths: - for root, _, files in os.walk(path): - for file in files: - yield os.path.join(root, file) + """Returns all files that are tracked by git in the given paths.""" + output = run_shell_command(["git", "ls-files"] + paths) + return output.split("\n") -def get_changed_lines(revision, filename, verbose): +def get_changed_lines(revision, filename): """Runs git diff to get the line ranges of all file changes.""" - output = git_diff(["--unified=0", revision, filename], verbose) + command = shlex.split("git diff-index --unified=0") + [revision, filename] + output = run_shell_command(command) changed_lines = [] for chunk in re.finditer(CHUNK_PATTERN, output, re.MULTILINE): start = int(chunk.group(1)) @@ -126,58 +106,56 @@ def run_clang_tidy(options, line_filters, files): with open(options.config_file) as config: # Here we convert the YAML config file to a JSON blob. command += ["-config", json.dumps(yaml.load(config))] - if options.checks: - command += ["-checks", options.checks] if line_filters: command += ["-line-filter", json.dumps(line_filters)] - command += ["-{}".format(arg) for arg in options.extra_args] + command += options.extra_args command += files - if options.verbose: - print(" ".join(command)) - if options.show_command_only: + if options.dry_run: command = [re.sub(r"^([{[].*[]}])$", r"'\1'", arg) for arg in command] return " ".join(command) - return run_shell_command(command) + output = run_shell_command(command) + if not options.keep_going and "[clang-diagnostic-error]" in output: + message = "Found clang-diagnostic-errors in clang-tidy output: {}" + raise RuntimeError(message.format(output)) + + return output def parse_options(): + """Parses the command line options.""" parser = argparse.ArgumentParser(description="Run Clang-Tidy (on your Git changes)") parser.add_argument( - "-c", + "-e", "--clang-tidy-exe", default="clang-tidy", help="Path to clang-tidy executable", ) - parser.add_argument( - "-e", - "--extra-args", - nargs="+", - default=[], - help="Extra arguments to forward to clang-tidy, without the hypen (e.g. -e 'header-filter=\"path\"')", - ) parser.add_argument( "-g", "--glob", nargs="+", default=[], - help="File patterns as UNIX globs (support * and ?, not recursive **)", + help="Only lint files that match these glob patterns " + "(see documentation for `fnmatch` for supported syntax)", ) parser.add_argument( "-x", "--regex", nargs="+", default=[], - help="File patterns as regular expressions", + help="Only lint files that match these regular expressions (from the start of the filename)", ) parser.add_argument( - "-d", + "-c", "--compile-commands-dir", - default=".", + default="build", help="Path to the folder containing compile_commands.json", ) - parser.add_argument("-r", "--revision", help="Git revision to get changes from") + parser.add_argument( + "-d", "--diff", help="Git revision to diff against to get changes" + ) parser.add_argument( "-p", "--paths", @@ -187,13 +165,7 @@ def parse_options(): ) parser.add_argument( "-n", - "--no-recursive", - action="store_true", - help="If paths are supplied with -p/--paths, do not recurse into paths", - ) - parser.add_argument( - "-s", - "--show-command-only", + "--dry-run", action="store_true", help="Only show the command to be executed, without running it", ) @@ -203,22 +175,33 @@ def parse_options(): help="Path to a clang-tidy config file. Defaults to '.clang-tidy'.", ) parser.add_argument( - "--checks", help="Appends checks to those from the config file (if any)" + "-k", + "--keep-going", + action="store_true", + help="Don't error on compiler errors (clang-diagnostic-error)", + ) + parser.add_argument( + "extra_args", nargs="*", help="Extra arguments to forward to clang-tidy" ) return parser.parse_args() def main(): options = parse_options() - paths = list(map(normalize_directory_path, options.paths)) - if options.revision: - files = get_changed_files(options.revision, paths, options.verbose) + + # This flag is pervasive enough to set it globally. It makes the code + # cleaner compared to threading it through every single function. + global VERBOSE + VERBOSE = options.verbose + + # Normalize the paths first. + paths = [path.rstrip("/") for path in options.paths] + if options.diff: + files = get_changed_files(options.diff, paths) else: files = get_all_files(paths) - if options.no_recursive: - files = remove_recursive_files(files, paths, options.verbose) file_patterns = get_file_patterns(options.glob, options.regex) - files = filter_files(files, file_patterns, options.verbose) + files = list(filter_files(files, file_patterns)) # clang-tidy error's when it does not get input files. if not files: @@ -226,12 +209,8 @@ def main(): sys.exit() line_filters = [] - if options.revision: - for filename in files: - changed_lines = get_changed_lines( - options.revision, filename, options.verbose - ) - line_filters.append(changed_lines) + if options.diff: + line_filters = [get_changed_lines(options.diff, f) for f in files] print(run_clang_tidy(options, line_filters, files)) diff --git a/tools/jit/gen_jit_dispatch.py b/tools/jit/gen_jit_dispatch.py index f6fdc7505d9966..4fc923589d4e06 100644 --- a/tools/jit/gen_jit_dispatch.py +++ b/tools/jit/gen_jit_dispatch.py @@ -64,7 +64,7 @@ def jit_type_of(arg): 'ScalarType': '{}.to()', 'Tensor': '{}.toTensor()', 'TensorList': '{}.toTensorList()->elements()', - 'bool': 'bool({}.toInt())', + 'bool': '{}.toBool()', 'double': '{}.toDouble()', 'int64_t': '{}.toInt()', 'std::string': '{}.toString()->string()', diff --git a/tools/run-clang-tidy-in-ci.sh b/tools/run-clang-tidy-in-ci.sh new file mode 100755 index 00000000000000..f7f865330f9b33 --- /dev/null +++ b/tools/run-clang-tidy-in-ci.sh @@ -0,0 +1,31 @@ +#!/bin/bash + +set -ex + +if [[ ! -d build ]]; then + git submodule update --init --recursive + + mkdir build + pushd build + # We really only need compile_commands.json, so no need to build! + time cmake -DBUILD_TORCH=ON .. + popd + + # Generate ATen files. + time python aten/src/ATen/gen.py \ + -s aten/src/ATen \ + -d build/aten/src/ATen \ + aten/src/ATen/Declarations.cwrap \ + aten/src/THNN/generic/THNN.h \ + aten/src/THCUNN/generic/THCUNN.h \ + aten/src/ATen/nn.yaml \ + aten/src/ATen/native/native_functions.yaml + + # Generate PyTorch files. + time python tools/setup_helpers/generate_code.py \ + --declarations-path build/aten/src/ATen/Declarations.yaml \ + --nn-path aten/src +fi + +# Run Clang-Tidy +time python tools/clang_tidy.py -vp torch/csrc -d HEAD~1 "$@" diff --git a/torch/CMakeLists.txt b/torch/CMakeLists.txt index 27e580e8965edf..fb1fb080002736 100644 --- a/torch/CMakeLists.txt +++ b/torch/CMakeLists.txt @@ -7,6 +7,7 @@ else() project(torch CXX C) find_package(Caffe2 REQUIRED) option(USE_CUDA "Use CUDA" ON) + set(CMAKE_EXPORT_COMPILE_COMMANDS ON) endif() option(BUILD_TEST "Build torch test binaries" ON) diff --git a/torch/csrc/autograd/profiler.h b/torch/csrc/autograd/profiler.h index 83058b9da5353e..93ca943361b2c7 100644 --- a/torch/csrc/autograd/profiler.h +++ b/torch/csrc/autograd/profiler.h @@ -22,7 +22,7 @@ #include #endif #ifndef _WIN32 -#include +#include #endif namespace torch { namespace autograd { diff --git a/torch/csrc/jit/attributes.h b/torch/csrc/jit/attributes.h index 2610643918b642..af3a16393fe9db 100644 --- a/torch/csrc/jit/attributes.h +++ b/torch/csrc/jit/attributes.h @@ -167,6 +167,7 @@ struct Attributes { const Kind##Attr::ValueType& method(Symbol name) const { \ return get(name); \ } + CREATE_ACCESSOR(Float,f) CREATE_ACCESSOR(Floats,fs) CREATE_ACCESSOR(String,s) diff --git a/torch/csrc/jit/autodiff.cpp b/torch/csrc/jit/autodiff.cpp index a59c856eaba751..46840fc99acd39 100644 --- a/torch/csrc/jit/autodiff.cpp +++ b/torch/csrc/jit/autodiff.cpp @@ -280,7 +280,7 @@ static std::vector gradientForNode(Node* node, ArrayRef grad_val } else if (node->matches("aten::mm(Tensor self, Tensor mat2) -> Tensor")) { return {grads.at(0).mm(inputs.at(1).t()), inputs.at(0).t().mm(grads.at(0))}; - } else if (node->matches("aten::expand(Tensor self, int[] size, *, int implicit) -> Tensor")) { + } else if (node->matches("aten::expand(Tensor self, int[] size, *, bool implicit) -> Tensor")) { const auto& input_sizes = inputs.at(0).sizes(); if (input_sizes.size() == 0) return {grads.at(0).sum(), nullptr, nullptr}; diff --git a/torch/csrc/jit/constants.cpp b/torch/csrc/jit/constants.cpp index 1633ac0de4d6aa..c62cdbd1fa051d 100644 --- a/torch/csrc/jit/constants.cpp +++ b/torch/csrc/jit/constants.cpp @@ -27,6 +27,13 @@ Value* insertConstant( } else if(val.isDouble()) { n->f_(attr::value, val.toDouble()); n->output()->setType(FloatType::get()); + } else if (val.isBool()) { + n->i_(attr::value, val.toBool()); + n->output()->setType(BoolType::get()); + } else if (val.isBoolList()) { + auto bool_list = val.toBoolList()->elements(); + n->is_(attr::value, std::vector(bool_list.begin(), bool_list.end())); + n->output()->setType(ListType::ofBools()); } else if(val.isIntList()) { n->is_(attr::value, val.toIntList()->elements()); n->output()->setType(ListType::ofInts()); @@ -64,6 +71,12 @@ RegisterOperators reg({ stack.push_back(t); return 0; }; + } else if (type->isSubtypeOf(BoolType::get())) { + bool b = node->i(attr::value); + return [b](Stack& stack) { + push(stack, b); + return 0; + }; } else if ( type->isSubtypeOf(NumberType::get()) && node->kindOf(attr::value) == AttributeKind::i) { @@ -86,6 +99,12 @@ RegisterOperators reg({ push(stack, is); return 0; }; + } else if(type->isSubtypeOf(ListType::ofBools())) { + auto bs = node->is(attr::value); + return [bs](Stack& stack) { + push(stack, bs); + return 0; + }; } else if(type->isSubtypeOf(ListType::ofTensors())) { auto ts = fmap(node->ts(attr::value), [](const at::Tensor & t) -> at::Tensor { return autograd::make_variable(t); diff --git a/torch/csrc/jit/export.cpp b/torch/csrc/jit/export.cpp index 973780b7d7d62f..574dae168a0b2c 100644 --- a/torch/csrc/jit/export.cpp +++ b/torch/csrc/jit/export.cpp @@ -559,6 +559,8 @@ void ModuleEncoder::EncodeTypeInfo( type_proto->set_denotation("FloatType"); } else if (kind == TypeKind::IntType) { type_proto->set_denotation("IntType"); + } else if (kind == TypeKind::BoolType) { + type_proto->set_denotation("BoolType"); } else if (kind == TypeKind::NoneType) { type_proto->set_denotation("NoneType"); } else if (kind == TypeKind::GeneratorType) { diff --git a/torch/csrc/jit/import.cpp b/torch/csrc/jit/import.cpp index 4574addb3a4465..45053a81db4abe 100644 --- a/torch/csrc/jit/import.cpp +++ b/torch/csrc/jit/import.cpp @@ -257,6 +257,8 @@ TypePtr ModuleDecoder::buildType(const onnx::TypeProto& type_proto) { return FloatType::get(); } else if (kind == "IntType") { return IntType::get(); + } else if (kind == "BoolType") { + return BoolType::get(); } else if (kind == "NoneType") { return NoneType::get(); } else if (kind == "GeneratorType") { diff --git a/torch/csrc/jit/interned_strings.cpp b/torch/csrc/jit/interned_strings.cpp index bf487484b25e09..228ec4414088d6 100644 --- a/torch/csrc/jit/interned_strings.cpp +++ b/torch/csrc/jit/interned_strings.cpp @@ -8,7 +8,7 @@ #include #include "ATen/core/Error.h" #include "ATen/core/optional.h" -#include "string.h" +#include #include "torch/csrc/jit/interned_strings_class.h" namespace torch { namespace jit { diff --git a/torch/csrc/jit/interned_strings.h b/torch/csrc/jit/interned_strings.h index b4e6b7c1398f1b..32544aa68258e1 100644 --- a/torch/csrc/jit/interned_strings.h +++ b/torch/csrc/jit/interned_strings.h @@ -46,9 +46,11 @@ namespace torch { namespace jit { _(prim, TupleUnpack) \ _(prim, ListConstruct) \ _(prim, ListUnpack) \ + _(prim, BoolToTensor) \ _(prim, NumToTensor) \ _(prim, TensorToNum) \ _(prim, ImplicitTensorToNum) \ + _(prim, TensorToBool) \ _(prim, IntToFloat) \ _(prim, FloatToInt) \ _(prim, StringToFloat) \ diff --git a/torch/csrc/jit/interned_strings_class.h b/torch/csrc/jit/interned_strings_class.h index 7dbf497d2739a6..babdb462c5bfc4 100644 --- a/torch/csrc/jit/interned_strings_class.h +++ b/torch/csrc/jit/interned_strings_class.h @@ -7,7 +7,7 @@ #include #include "ATen/core/Error.h" #include "ATen/core/optional.h" -#include "string.h" +#include #include "torch/csrc/jit/interned_strings.h" namespace torch { diff --git a/torch/csrc/jit/interpreter.cpp b/torch/csrc/jit/interpreter.cpp index 14e7fab54d9549..065054a0fc43d9 100644 --- a/torch/csrc/jit/interpreter.cpp +++ b/torch/csrc/jit/interpreter.cpp @@ -61,14 +61,14 @@ Value* createTripCountConjunctiveCondition( // Emit initial comparison -- initial_trip_count < max_trip_count Value* initial_comparison_value = g->insertNode(g->create(aten::lt, {cur_trip_count, max_trip_count}, 1)) - ->output()->setType(IntType::get()); + ->output()->setType(BoolType::get()); // Replace initial condition with logical `and` of trip count and // initial condition Value* new_cond = g->insertNode( g->create(aten::__and__, {initial_comparison_value, cond}, 1)) - ->output()->setType(IntType::get()); + ->output()->setType(BoolType::get()); return new_cond; } @@ -388,30 +388,29 @@ struct CodeImpl { CodeImpl(std::shared_ptr& graph_) : preprocess(*graph_) { graph = preprocess.graph; - // std::cout << "into code graph:\n" << *graph << "\n"; insertNodesFromBlock(graph->block()); } - // jump when input is 0 - void createJumpZ(int from_inst, int to_inst) { + // jump when input is false + void createJumpFalse(int from_inst, int to_inst) { auto & inst = instructions[from_inst]; JIT_ASSERT(inst.debug_name == prim::Placeholder); auto offset = relativeJump(from_inst, to_inst); inst.callback = [offset](Stack & stack) { - auto t = pop(stack).toInt(); - return (t == 0) ? offset : 0; + auto t = pop(stack).toBool(); + return t ? 0 : offset; }; inst.debug_name = prim::JumpZ; } - // jump when input is not 0 - void createJumpNZ(int from_inst, int to_inst) { + // jump when input is true + void createJumpTrue(int from_inst, int to_inst) { auto & inst = instructions[from_inst]; JIT_ASSERT(inst.debug_name == prim::Placeholder); auto offset = relativeJump(from_inst, to_inst); inst.callback = [offset](Stack & stack) { - auto t = pop(stack).toInt(); - return (t != 0) ? offset : 0; + auto t = pop(stack).toBool(); + return t ? offset : 0; }; inst.debug_name = prim::JumpNZ; } @@ -460,7 +459,7 @@ struct CodeImpl { insertNodesFromBlock(then_block); insertAssign(source_location, then_block->outputs(), moveFlags(then_block), node->outputs()); createJump(jump, instructions.size()); - createJumpNZ(cond_branch, then_block_start); + createJumpTrue(cond_branch, then_block_start); } break; case prim::Loop: { // o0 = while c i0 @@ -495,8 +494,8 @@ struct CodeImpl { // after branch: stack: ... aliasRegistersTo(node->outputs(), body_block->inputs()); - createJumpZ(cond_branch, instructions.size()); - createJumpNZ(cond_branch_end, entry); + createJumpFalse(cond_branch, instructions.size()); + createJumpTrue(cond_branch_end, entry); } break; default: { insertInstruction(node); diff --git a/torch/csrc/jit/ir.cpp b/torch/csrc/jit/ir.cpp index 90451494bacbc7..4e4bb0b68d52c2 100644 --- a/torch/csrc/jit/ir.cpp +++ b/torch/csrc/jit/ir.cpp @@ -562,18 +562,18 @@ namespace { const OperatorSet& nondeterminstic_aten_ops() { static OperatorSet nondeterministic_ops = { - "aten::dropout(Tensor input, float p, int train) -> Tensor", + "aten::dropout(Tensor input, float p, bool train) -> Tensor", "aten::_fused_dropout(Tensor self, float p, Generator generator) -> (Tensor, Tensor)", "aten::_standard_gamma(Tensor self, Generator generator) -> Tensor", "aten::bernoulli(Tensor self, *, Generator generator) -> Tensor", "aten::bernoulli(Tensor self, float p, *, Generator generator) -> Tensor", - "aten::multinomial(Tensor self, int num_samples, int replacement, *, Generator generator) -> Tensor", + "aten::multinomial(Tensor self, int num_samples, bool replacement, *, Generator generator) -> Tensor", "aten::normal(Tensor mean, Tensor std, *, Generator generator) -> Tensor", "aten::normal(float mean, Tensor std, *, Generator generator) -> Tensor", "aten::normal(Tensor mean, float std, *, Generator generator) -> Tensor", "aten::poisson(Tensor self, Generator generator) -> Tensor", - "aten::rrelu(Tensor self, Scalar lower, Scalar upper, int training, Generator generator) -> Tensor", - "aten::rrelu_with_noise(Tensor self, Tensor noise, Scalar lower, Scalar upper, int training, Generator generator) -> Tensor", + "aten::rrelu(Tensor self, Scalar lower, Scalar upper, bool training, Generator generator) -> Tensor", + "aten::rrelu_with_noise(Tensor self, Tensor noise, Scalar lower, Scalar upper, bool training, Generator generator) -> Tensor", "aten::rand(int[] size, *, int dtype, int layout, int[] device) -> Tensor", "aten::rand_like(Tensor self) -> Tensor", "aten::rand_like(Tensor self, *, int dtype, int layout, int[] device) -> Tensor", @@ -598,7 +598,7 @@ bool Node::isNondeterministic() const { return false; } // Dropout with train = False is deterministic - if (matches("aten::dropout(Tensor input, float p, int train) -> Tensor") && is_constant(attr::train) && !get(attr::train).value()) { + if (matches("aten::dropout(Tensor input, float p, bool train) -> Tensor") && is_constant(attr::train) && !get(attr::train).value()) { return false; } return true; diff --git a/torch/csrc/jit/ir.h b/torch/csrc/jit/ir.h index 0bb5c899c7321d..6fdb49e7d95aa3 100644 --- a/torch/csrc/jit/ir.h +++ b/torch/csrc/jit/ir.h @@ -1050,6 +1050,15 @@ friend struct Block; result->output()->setType(CompleteTensorType::fromNumberType(typ)); return result; } + Node* createBoolToTensor(Value* value) { + auto typ = value->type(); + Node * result = create(prim::BoolToTensor, {value}); + if (!typ->isSubtypeOf(BoolType::get())) { + AT_ERROR("Cannot create bool type from ", typ->str()); + } + result->output()->setType(CompleteTensorType::fromBoolType()); + return result; + } Node* createTensorToNum(const TypePtr& type, Value* value) { auto* result = create(prim::TensorToNum, {value}); result->output()->setType(type); @@ -1060,6 +1069,11 @@ friend struct Block; result->output()->setType(type); return result; } + Node* createTensorToBool(Value* value) { + auto* result = create(prim::TensorToBool, {value}); + result->output()->setType(BoolType::get()); + return result; + } Node* createIntToFloat(Value* value) { JIT_ASSERT(*value->type() == *IntType::get()); auto* result = create(prim::IntToFloat, {value}); diff --git a/torch/csrc/jit/operator.cpp b/torch/csrc/jit/operator.cpp index d701b536c44a0c..818a58c9650db7 100644 --- a/torch/csrc/jit/operator.cpp +++ b/torch/csrc/jit/operator.cpp @@ -57,7 +57,7 @@ struct SchemaParser { {"str", StringType::get() }, {"float", FloatType::get() }, {"int", IntType::get() }, - {"bool", IntType::get() }, // TODO: add separate bool type + {"bool", BoolType::get() }, {"World", WorldType::get() }, }; auto tok = L.expect(TK_IDENT); @@ -162,6 +162,10 @@ struct SchemaParser { return fmap(vs, [](IValue v) { return v.toInt(); }); + case TypeKind::BoolType: + return fmap(vs, [](IValue v) { + return v.toBool(); + }); default: throw ErrorReport(range) << "lists are only supported for float or int types."; } @@ -191,6 +195,7 @@ struct SchemaParser { } break; case TypeKind::NumberType: case TypeKind::IntType: + case TypeKind::BoolType: case TypeKind::FloatType: arg.default_value = parseSingleConstant(arg.type->kind()); break; diff --git a/torch/csrc/jit/passes/erase_number_types.cpp b/torch/csrc/jit/passes/erase_number_types.cpp index 7d2ba5bfebf1d2..115d4b6a68c237 100644 --- a/torch/csrc/jit/passes/erase_number_types.cpp +++ b/torch/csrc/jit/passes/erase_number_types.cpp @@ -13,13 +13,16 @@ static void EraseNumberTypesOnBlock(Block* block) { case prim::Constant: { // remove primitive constants, replacing with tensor equivalent // ONNX does not support non-tensor constants - if(it->output()->type()->isSubtypeOf(NumberType::get())) { + if (it->output()->type()->isSubtypeOf(NumberType::get()) || + it->output()->type()->isSubtypeOf(BoolType::get())) { auto s = *constant_as(it->output()); WithInsertPoint guard(*it); Value* r = block->owningGraph()->insertConstant(scalar_to_tensor(s)); it->output()->replaceAllUsesWith(r); } } break; + case prim::TensorToBool: + case prim::BoolToTensor: case prim::TensorToNum: case prim::ImplicitTensorToNum: case prim::NumToTensor: { @@ -30,6 +33,8 @@ static void EraseNumberTypesOnBlock(Block* block) { for(auto o : it->outputs()) { if (o->type()->isSubtypeOf(NumberType::get())) { o->setType(CompleteTensorType::fromNumberType(o->type())); + } else if (o->type()->isSubtypeOf(BoolType::get())) { + o->setType(CompleteTensorType::fromBoolType()); } } } break; diff --git a/torch/csrc/jit/passes/peephole.cpp b/torch/csrc/jit/passes/peephole.cpp index 176166218fc01a..7f2312696e3a05 100644 --- a/torch/csrc/jit/passes/peephole.cpp +++ b/torch/csrc/jit/passes/peephole.cpp @@ -24,7 +24,7 @@ void PeepholeOptimize(Block * block) { // XXX: remember that if you want to simplify an expression by combining multiple nodes // into a different one, then you need to check that they all belong to the given block - if (node->matches("aten::expand(Tensor self, int[] size, *, int implicit) -> Tensor", + if (node->matches("aten::expand(Tensor self, int[] size, *, bool implicit) -> Tensor", /*with_const=*/attr::size)) { // x.expand(x.size()) == x if (auto input_type = node->namedInput(attr::self)->type()->cast()) { diff --git a/torch/csrc/jit/passes/remove_expands.cpp b/torch/csrc/jit/passes/remove_expands.cpp index 93d53e54819bbd..1c67e6850719b4 100644 --- a/torch/csrc/jit/passes/remove_expands.cpp +++ b/torch/csrc/jit/passes/remove_expands.cpp @@ -8,7 +8,8 @@ static void RemoveExpands(Block* block) { ++it) { for (auto sub : it->blocks()) RemoveExpands(sub); - if (it->kind() == aten::expand && it->get(attr::implicit) != static_cast(0)) { + + if (it->kind() == aten::expand && it->get(attr::implicit) == true) { it->output()->replaceAllUsesWith(it->namedInput(attr::self)); it.destroyCurrent(); } diff --git a/torch/csrc/jit/passes/shape_analysis.cpp b/torch/csrc/jit/passes/shape_analysis.cpp index eedc7fd0a8a686..af5e8cd96fbb32 100644 --- a/torch/csrc/jit/passes/shape_analysis.cpp +++ b/torch/csrc/jit/passes/shape_analysis.cpp @@ -120,7 +120,7 @@ void broadcastBinary(Node *node, std::vector& types, size Node *expand = graph->create(aten::expand, {node->inputs().at(input_idx), graph->insertConstant(expected_size), - graph->insertConstant(0)}) + graph->insertConstant(false)}) ->insertBefore(node); PropagateShapeOnNode(expand); node->replaceInput(input_idx, expand->output()); @@ -441,12 +441,12 @@ bool PropagateTensorShapeOnNode(Node * node, bool insert_expands) { "aten::clamp(Tensor self, Scalar min, Scalar max) -> Tensor", "aten::clamp_max(Tensor self, Scalar max) -> Tensor", "aten::clamp_min(Tensor self, Scalar min) -> Tensor", - "aten::alpha_dropout(Tensor input, float p, int train) -> Tensor", + "aten::alpha_dropout(Tensor input, float p, bool train) -> Tensor", "aten::bernoulli(Tensor self, float p, *, Generator generator) -> Tensor", "aten::cos(Tensor self) -> Tensor", "aten::cosh(Tensor self) -> Tensor", "aten::digamma(Tensor self) -> Tensor", - "aten::dropout(Tensor input, float p, int train) -> Tensor", + "aten::dropout(Tensor input, float p, bool train) -> Tensor", "aten::elu(Tensor self, Scalar alpha, Scalar scale, Scalar input_scale) -> Tensor", "aten::erf(Tensor self) -> Tensor", "aten::erfc(Tensor self) -> Tensor", @@ -462,8 +462,8 @@ bool PropagateTensorShapeOnNode(Node * node, bool insert_expands) { "aten::floor(Tensor self) -> Tensor", "aten::frac(Tensor self) -> Tensor", "aten::flip(Tensor self, int[] dims) -> Tensor", - "aten::feature_alpha_dropout(Tensor input, float p, int train) -> Tensor", - "aten::feature_dropout(Tensor input, float p, int train) -> Tensor", + "aten::feature_alpha_dropout(Tensor input, float p, bool train) -> Tensor", + "aten::feature_dropout(Tensor input, float p, bool train) -> Tensor", "aten::hardshrink(Tensor self, Scalar lambd) -> Tensor", "aten::hardtanh(Tensor self, Scalar min_val, Scalar max_val) -> Tensor", "aten::glu(Tensor self, int dim) -> Tensor", @@ -479,7 +479,7 @@ bool PropagateTensorShapeOnNode(Node * node, bool insert_expands) { "aten::reciprocal(Tensor self) -> Tensor", "aten::relu(Tensor self) -> Tensor", "aten::round(Tensor self) -> Tensor", - "aten::rrelu(Tensor self, Scalar lower, Scalar upper, int training, Generator generator) -> Tensor", + "aten::rrelu(Tensor self, Scalar lower, Scalar upper, bool training, Generator generator) -> Tensor", "aten::rsqrt(Tensor self) -> Tensor", "aten::selu(Tensor self) -> Tensor", "aten::sigmoid(Tensor self) -> Tensor", @@ -645,7 +645,7 @@ bool PropagateTensorShapeOnNode(Node * node, bool insert_expands) { // Knowing the type and device of weights or biases is usually enough to // infer the output type. static const register_formula_for nn_ops_first_input_preserving {{ - "aten::batch_norm(Tensor input, Tensor weight, Tensor bias, Tensor running_mean, Tensor running_var, int training, float momentum, float eps, int cudnn_enabled) -> Tensor", + "aten::batch_norm(Tensor input, Tensor weight, Tensor bias, Tensor running_mean, Tensor running_var, bool training, float momentum, float eps, bool cudnn_enabled) -> Tensor", "aten::conv1d(Tensor input, Tensor weight, Tensor bias, int[] stride, int[] padding, int[] dilation, int groups) -> Tensor", "aten::conv2d(Tensor input, Tensor weight, Tensor bias, int[] stride, int[] padding, int[] dilation, int groups) -> Tensor", "aten::conv3d(Tensor input, Tensor weight, Tensor bias, int[] stride, int[] padding, int[] dilation, int groups) -> Tensor", @@ -653,16 +653,16 @@ bool PropagateTensorShapeOnNode(Node * node, bool insert_expands) { "aten::conv_transpose1d(Tensor input, Tensor weight, Tensor bias, int[] stride, int[] padding, int[] output_padding, int groups, int[] dilation) -> Tensor", "aten::conv_transpose2d(Tensor input, Tensor weight, Tensor bias, int[] stride, int[] padding, int[] output_padding, int groups, int[] dilation) -> Tensor", "aten::conv_transpose3d(Tensor input, Tensor weight, Tensor bias, int[] stride, int[] padding, int[] output_padding, int groups, int[] dilation) -> Tensor", - "aten::convolution(Tensor input, Tensor weight, Tensor bias, int[] stride, int[] padding, int[] dilation, int transposed, int[] output_padding, int groups) -> Tensor", + "aten::convolution(Tensor input, Tensor weight, Tensor bias, int[] stride, int[] padding, int[] dilation, bool transposed, int[] output_padding, int groups) -> Tensor", "aten::adaptive_avg_pool1d(Tensor self, int[] output_size) -> Tensor", "aten::adaptive_avg_pool2d(Tensor self, int[] output_size) -> Tensor", "aten::adaptive_avg_pool3d(Tensor self, int[] output_size) -> Tensor", - "aten::avg_pool1d(Tensor self, int[] kernel_size, int[] stride, int[] padding, int ceil_mode, int count_include_pad) -> Tensor", - "aten::avg_pool2d(Tensor self, int[] kernel_size, int[] stride, int[] padding, int ceil_mode, int count_include_pad) -> Tensor", - "aten::avg_pool3d(Tensor self, int[] kernel_size, int[] stride, int[] padding, int ceil_mode, int count_include_pad) -> Tensor", - "aten::max_pool1d(Tensor self, int[] kernel_size, int[] stride, int[] padding, int[] dilation, int ceil_mode) -> Tensor", - "aten::max_pool2d(Tensor self, int[] kernel_size, int[] stride, int[] padding, int[] dilation, int ceil_mode) -> Tensor", - "aten::max_pool3d(Tensor self, int[] kernel_size, int[] stride, int[] padding, int[] dilation, int ceil_mode) -> Tensor", + "aten::avg_pool1d(Tensor self, int[] kernel_size, int[] stride, int[] padding, bool ceil_mode, bool count_include_pad) -> Tensor", + "aten::avg_pool2d(Tensor self, int[] kernel_size, int[] stride, int[] padding, bool ceil_mode, bool count_include_pad) -> Tensor", + "aten::avg_pool3d(Tensor self, int[] kernel_size, int[] stride, int[] padding, bool ceil_mode, bool count_include_pad) -> Tensor", + "aten::max_pool1d(Tensor self, int[] kernel_size, int[] stride, int[] padding, int[] dilation, bool ceil_mode) -> Tensor", + "aten::max_pool2d(Tensor self, int[] kernel_size, int[] stride, int[] padding, int[] dilation, bool ceil_mode) -> Tensor", + "aten::max_pool3d(Tensor self, int[] kernel_size, int[] stride, int[] padding, int[] dilation, bool ceil_mode) -> Tensor", "aten::max_unpool2d(Tensor self, Tensor indices, int[] output_size) -> Tensor", "aten::max_unpool3d(Tensor self, Tensor indices, int[] output_size, int[] stride, int[] padding) -> Tensor", "aten::reflection_pad1d(Tensor self, int[] padding) -> Tensor", @@ -670,12 +670,12 @@ bool PropagateTensorShapeOnNode(Node * node, bool insert_expands) { "aten::replication_pad1d(Tensor self, int[] padding) -> Tensor", "aten::replication_pad2d(Tensor self, int[] padding) -> Tensor", "aten::replication_pad3d(Tensor self, int[] padding) -> Tensor", - "aten::upsample_bilinear2d(Tensor self, int[] output_size, int align_corners) -> Tensor", - "aten::upsample_linear1d(Tensor self, int[] output_size, int align_corners) -> Tensor", + "aten::upsample_bilinear2d(Tensor self, int[] output_size, bool align_corners) -> Tensor", + "aten::upsample_linear1d(Tensor self, int[] output_size, bool align_corners) -> Tensor", "aten::upsample_nearest1d(Tensor self, int[] output_size) -> Tensor", "aten::upsample_nearest2d(Tensor self, int[] output_size) -> Tensor", "aten::upsample_nearest3d(Tensor self, int[] output_size) -> Tensor", - "aten::upsample_trilinear3d(Tensor self, int[] output_size, int align_corners) -> Tensor", + "aten::upsample_trilinear3d(Tensor self, int[] output_size, bool align_corners) -> Tensor", "aten::prelu(Tensor self, Tensor weight) -> Tensor", }, [](Node * node) -> type_vec_t { if (auto type = node->input(0)->type()->cast()) { @@ -702,10 +702,10 @@ bool PropagateTensorShapeOnNode(Node * node, bool insert_expands) { "aten::mean(Tensor self) -> Tensor", "aten::median(Tensor self) -> Tensor", "aten::norm(Tensor self, Scalar p) -> Tensor", - "aten::std(Tensor self, int unbiased) -> Tensor", + "aten::std(Tensor self, bool unbiased) -> Tensor", "aten::sum(Tensor self) -> Tensor", "aten::trace(Tensor self) -> Tensor", - "aten::var(Tensor self, int unbiased) -> Tensor", + "aten::var(Tensor self, bool unbiased) -> Tensor", "aten::all(Tensor self) -> Tensor", "aten::any(Tensor self) -> Tensor", }, [](Node * node) -> type_vec_t { @@ -735,7 +735,7 @@ bool PropagateTensorShapeOnNode(Node * node, bool insert_expands) { static const auto multidim_reduce_with_postprocess = [](Node * node, size_t num_reduced_dim, bool upcast_integer) -> type_vec_t { - auto maybe_keepdim = node->get(attr::keepdim); + auto maybe_keepdim = node->get(attr::keepdim); if (!maybe_keepdim) return {}; if (auto type = node->input(0)->type()->cast()) { if (upcast_integer && !at::isFloatingType(type->scalarType())) { @@ -760,24 +760,24 @@ bool PropagateTensorShapeOnNode(Node * node, bool insert_expands) { // - First input should be the only tensor input // - Has a bool keepdim argument static const register_formula_for dim_reduce_ops {{ - "aten::argmax(Tensor self, int dim, int keepdim) -> Tensor", - "aten::argmin(Tensor self, int dim, int keepdim) -> Tensor", - "aten::max_values(Tensor self, int dim, int keepdim) -> Tensor", - "aten::min_values(Tensor self, int dim, int keepdim) -> Tensor", - "aten::mean(Tensor self, int dim, int keepdim) -> Tensor", - "aten::norm(Tensor self, Scalar p, int dim, int keepdim) -> Tensor", - "aten::std(Tensor self, int dim, int unbiased, int keepdim) -> Tensor", - "aten::var(Tensor self, int dim, int unbiased, int keepdim) -> Tensor", - "aten::logsumexp(Tensor self, int dim, int keepdim) -> Tensor", - "aten::all(Tensor self, int dim, int keepdim) -> Tensor", - "aten::any(Tensor self, int dim, int keepdim) -> Tensor", + "aten::argmax(Tensor self, int dim, bool keepdim) -> Tensor", + "aten::argmin(Tensor self, int dim, bool keepdim) -> Tensor", + "aten::max_values(Tensor self, int dim, bool keepdim) -> Tensor", + "aten::min_values(Tensor self, int dim, bool keepdim) -> Tensor", + "aten::mean(Tensor self, int dim, bool keepdim) -> Tensor", + "aten::norm(Tensor self, Scalar p, int dim, bool keepdim) -> Tensor", + "aten::std(Tensor self, int dim, bool unbiased, bool keepdim) -> Tensor", + "aten::var(Tensor self, int dim, bool unbiased, bool keepdim) -> Tensor", + "aten::logsumexp(Tensor self, int dim, bool keepdim) -> Tensor", + "aten::all(Tensor self, int dim, bool keepdim) -> Tensor", + "aten::any(Tensor self, int dim, bool keepdim) -> Tensor", // Ops returning indices as second output - "aten::kthvalue(Tensor self, int k, int dim, int keepdim) -> (Tensor, Tensor)", - "aten::max(Tensor self, int dim, int keepdim) -> (Tensor, Tensor)", - "aten::min(Tensor self, int dim, int keepdim) -> (Tensor, Tensor)", - "aten::median(Tensor self, int dim, int keepdim) -> (Tensor, Tensor)", - "aten::mode(Tensor self, int dim, int keepdim) -> (Tensor, Tensor)", + "aten::kthvalue(Tensor self, int k, int dim, bool keepdim) -> (Tensor, Tensor)", + "aten::max(Tensor self, int dim, bool keepdim) -> (Tensor, Tensor)", + "aten::min(Tensor self, int dim, bool keepdim) -> (Tensor, Tensor)", + "aten::median(Tensor self, int dim, bool keepdim) -> (Tensor, Tensor)", + "aten::mode(Tensor self, int dim, bool keepdim) -> (Tensor, Tensor)", }, [](Node * node) -> type_vec_t { // NB: Note that while this function is generally meant to be used with ops that // have a single output, we will fix up its return right below. @@ -798,7 +798,7 @@ bool PropagateTensorShapeOnNode(Node * node, bool insert_expands) { // - First input should be the only tensor input // - has a bool keepdim argument static const register_formula_for dim_reduce_ops_with_integer_upcast {{ - "aten::prod(Tensor self, int dim, int keepdim) -> Tensor", + "aten::prod(Tensor self, int dim, bool keepdim) -> Tensor", }, [](Node * node) -> type_vec_t { return multidim_reduce_with_postprocess(node, /*num_reduce_dim=*/1, /*integer_upcast=*/true); }}; @@ -812,7 +812,7 @@ bool PropagateTensorShapeOnNode(Node * node, bool insert_expands) { // Additionally: // - has bool keepdim and int[] dim arguments static const register_formula_for multidim_reduce_ops_with_integer_upcast {{ - "aten::sum(Tensor self, int[] dim, int keepdim) -> Tensor", + "aten::sum(Tensor self, int[] dim, bool keepdim) -> Tensor", }, [](Node * node) -> type_vec_t { if (auto dim = node->get>(attr::dim)) { // TODO: can dim contain duplicates? @@ -900,14 +900,14 @@ bool PropagateTensorShapeOnNode(Node * node, bool insert_expands) { } }; static const register_formula_for cast_ops {{ - "aten::_cast_Byte(Tensor self, int non_blocking) -> Tensor", - "aten::_cast_Char(Tensor self, int non_blocking) -> Tensor", - "aten::_cast_Double(Tensor self, int non_blocking) -> Tensor", - "aten::_cast_Float(Tensor self, int non_blocking) -> Tensor", - "aten::_cast_Half(Tensor self, int non_blocking) -> Tensor", - "aten::_cast_Int(Tensor self, int non_blocking) -> Tensor", - "aten::_cast_Long(Tensor self, int non_blocking) -> Tensor", - "aten::_cast_Short(Tensor self, int non_blocking) -> Tensor", + "aten::_cast_Byte(Tensor self, bool non_blocking) -> Tensor", + "aten::_cast_Char(Tensor self, bool non_blocking) -> Tensor", + "aten::_cast_Double(Tensor self, bool non_blocking) -> Tensor", + "aten::_cast_Float(Tensor self, bool non_blocking) -> Tensor", + "aten::_cast_Half(Tensor self, bool non_blocking) -> Tensor", + "aten::_cast_Int(Tensor self, bool non_blocking) -> Tensor", + "aten::_cast_Long(Tensor self, bool non_blocking) -> Tensor", + "aten::_cast_Short(Tensor self, bool non_blocking) -> Tensor", }, [](Node * node) -> type_vec_t { if (auto type = node->namedInput(attr::self)->type()->cast()) { return {type->toScalarType(get_cast_scalar_type(node))}; @@ -1003,7 +1003,7 @@ bool PropagateTensorShapeOnNode(Node * node, bool insert_expands) { } return true; } - } else if (node->matches("aten::embedding(Tensor weight, Tensor indices, int padding_idx, int scale_grad_by_freq, int sparse) -> Tensor")) { + } else if (node->matches("aten::embedding(Tensor weight, Tensor indices, int padding_idx, bool scale_grad_by_freq, bool sparse) -> Tensor")) { auto weight_type = input_type(0); auto indices_type = input_type(1); if (weight_type && indices_type) { @@ -1044,7 +1044,7 @@ bool PropagateTensorShapeOnNode(Node * node, bool insert_expands) { node->matches("aten::reshape_as(Tensor self, Tensor other) -> Tensor")) { return tensor_types.at(0)->withDim(tensor_types.at(1)->dim()); } else if (node->matches("aten::view(Tensor self, int[] size) -> Tensor") || - node->matches("aten::expand(Tensor self, int[] size, *, int implicit) -> Tensor") || + node->matches("aten::expand(Tensor self, int[] size, *, bool implicit) -> Tensor") || node->matches("aten::as_strided(Tensor self, int[] size, int[] stride) -> Tensor") || node->matches("aten::as_strided(Tensor self, int[] size, int[] stride, int storage_offset) -> Tensor")) { return reshape_prop(node, attr::size, tensor_types); @@ -1189,12 +1189,12 @@ bool PropagateCompleteShapeOnNode(Node * node, bool insert_expands, } else if (node->matches("aten::sum(Tensor self) -> Tensor")) { node->output()->setType(tensor_types.at(0)->withSizes({})); return true; - } else if (node->matches("aten::sum(Tensor self, int[] dim, int keepdim) -> Tensor", + } else if (node->matches("aten::sum(Tensor self, int[] dim, bool keepdim) -> Tensor", /*with_const=*/{attr::dim, attr::keepdim})) { auto & tp = tensor_types.at(0); auto sizes = tp->sizes(); auto dims = node->get>(attr::dim).value(); - bool keepdim = node->get(attr::keepdim).value(); + bool keepdim = node->get(attr::keepdim).value(); std::reverse(dims.begin(), dims.end()); for (int64_t dim : dims) { SHAPE_ASSERT(dim >= 0 && static_cast(dim) < sizes.size()); @@ -1262,7 +1262,7 @@ bool PropagateCompleteShapeOnNode(Node * node, bool insert_expands, node->output()->setType(tensor_types.at(1)->withSizes(tensor_types.at(0)->sizes())); } return true; - } else if (node->matches("aten::expand(Tensor self, int[] size, *, int implicit) -> Tensor", + } else if (node->matches("aten::expand(Tensor self, int[] size, *, bool implicit) -> Tensor", /*with_const=*/attr::size)) { auto tp = tensor_types.at(0); std::vector sizes, strides; diff --git a/torch/csrc/jit/passes/to_batch.cpp b/torch/csrc/jit/passes/to_batch.cpp index 0d56ca2255286f..f1edf80d41f209 100644 --- a/torch/csrc/jit/passes/to_batch.cpp +++ b/torch/csrc/jit/passes/to_batch.cpp @@ -41,6 +41,10 @@ void ToBatch::visitAten(Node* n, Block* block, Block* res_block){ auto to_tensor_node = res_graph->createNumToTensor(input); res_graph->insertNode(to_tensor_node); new_inputs[i] = to_tensor_node->output(); + } else if(input->type() == BoolType::get()) { + auto to_tensor_node = res_graph->createBoolToTensor(input); + res_graph->insertNode(to_tensor_node); + new_inputs[i] = to_tensor_node->output(); } } @@ -58,8 +62,11 @@ void ToBatch::visitAten(Node* n, Block* block, Block* res_block){ else if(n->outputs()[0]->type() == FloatType::get()){ to_scalar_node = res_graph->createTensorToNum(FloatType::get(), outputs[0]); } + else if(n->outputs()[0]->type() == BoolType::get()){ + to_scalar_node = res_graph->createTensorToBool(outputs[0]); + } else{ - throw std::runtime_error("NYI: scalar type other than int, float is not supported yet"); + throw std::runtime_error("NYI: scalar types other than int, float, and bool are not supported yet"); } res_graph->insertNode(to_scalar_node); rn_env[n->outputs()[0]] = to_scalar_node->output(); @@ -348,9 +355,10 @@ void ToBatch::visitLoop(Node* n, Block* block, Block* res_block){ if(cond_is_tensor){ auto cond = batch_map.at(n->inputs()[1]); auto cond_any = script::inlineCallTo(*res_block->owningGraph(), *getBatchOperator("any"), cond); - auto to_int_node = res_graph->createTensorToNum(IntType::get(), cond_any[0]); - res_graph->insertNode(to_int_node); - rn_env[n->inputs()[1]] = to_int_node->output(); + auto to_bool_node = + res_graph->createTensorToBool(cond_any[0]); + res_graph->insertNode(to_bool_node); + rn_env[n->inputs()[1]] = to_bool_node->output(); } for(size_t i = 2; i < n->inputs().size(); i++){ auto input = n->inputs()[i]; @@ -432,9 +440,10 @@ void ToBatch::visitLoop(Node* n, Block* block, Block* res_block){ if(cond_is_tensor){ auto cond = batch_map.at(n->blocks()[0]->outputs()[0]); auto cond_any = script::inlineCallTo(*res_block->owningGraph(), *getBatchOperator("any"), cond); - auto to_int_node = res_graph->createTensorToNum(IntType::get(), cond_any[0]); - res_graph->insertNode(to_int_node); - loop_block->insertOutput(0, to_int_node->output()); + auto to_bool_node = + res_graph->createTensorToBool(cond_any[0]); + res_graph->insertNode(to_bool_node); + loop_block->insertOutput(0, to_bool_node->output()); for(size_t i = 0; i < EXP_BTENSOR_SIZE; i++){ loop_block->insertOutput(i + 1, cond[i]); } @@ -491,6 +500,7 @@ void ToBatch::toBatch(Block* block, Block* res_block) { case prim::NumToTensor: visitNumToTensor(n, block, res_block); break; + case prim::TensorToBool: case prim::TensorToNum: visitTensorToNum(n, block, res_block); break; diff --git a/torch/csrc/jit/pybind_utils.h b/torch/csrc/jit/pybind_utils.h index 192cabca3f38d1..bd81a8cc057389 100644 --- a/torch/csrc/jit/pybind_utils.h +++ b/torch/csrc/jit/pybind_utils.h @@ -107,6 +107,8 @@ inline IValue toIValue(py::handle obj, const TypePtr& type) { return py::cast(obj); case TypeKind::NoneType: return {}; + case TypeKind::BoolType: + return py::cast(obj); case TypeKind::TupleType: { if(!PyTuple_Check(obj.ptr())) throw py::cast_error(); // note: the py::cast does not throw cast_error @@ -196,10 +198,14 @@ inline py::object toPyObject(IValue&& ivalue) { return py::cast(ivalue.toDouble()); } else if (ivalue.isInt()) { return py::cast(ivalue.toInt()); + }else if (ivalue.isBool()) { + return py::cast(ivalue.toBool()); } else if (ivalue.isIntList()) { return py::cast(ivalue.toIntListRef()); } else if (ivalue.isDoubleList()) { return py::cast(ivalue.toDoubleListRef()); + } else if (ivalue.isBoolList()) { + return py::cast(ivalue.toBoolListRef()); } else if (ivalue.isTensorList()) { return py::cast(ivalue.toTensorListRef()); } else if (ivalue.isGenericList()) { diff --git a/torch/csrc/jit/python_interpreter.cpp b/torch/csrc/jit/python_interpreter.cpp index 5c2115a20413d8..6daac16a494659 100644 --- a/torch/csrc/jit/python_interpreter.cpp +++ b/torch/csrc/jit/python_interpreter.cpp @@ -19,6 +19,7 @@ #include "torch/csrc/autograd/python_variable.h" #include "torch/csrc/jit/pybind.h" #include "torch/csrc/utils/auto_gil.h" +#include "torch/csrc/Exceptions.h" namespace py = pybind11; @@ -53,8 +54,12 @@ Operation createPythonOperation(Node* op_) { i++; } drop(stack, num_inputs); - py::object py_output(func(*py_inputs)); - stack.push_back(returnToIValue(op->output()->type(), py_output)); + try { + py::object py_output(func(*py_inputs)); + stack.push_back(returnToIValue(op->output()->type(), py_output)); + } catch (py::error_already_set & e) { + throw python_error(); + } return 0; }; } diff --git a/torch/csrc/jit/python_ir.cpp b/torch/csrc/jit/python_ir.cpp index ad03ac556cd272..979b07d36908ea 100644 --- a/torch/csrc/jit/python_ir.cpp +++ b/torch/csrc/jit/python_ir.cpp @@ -455,6 +455,8 @@ void initPythonIRBindings(PyObject * module_) { return "StringType"; case TypeKind::GeneratorType: return "GeneratorType"; + case TypeKind::BoolType: + return "BoolType"; case TypeKind::VarType: return "VarType"; case TypeKind::WorldType: @@ -491,6 +493,8 @@ void initPythonIRBindings(PyObject * module_) { .def_static("get", &FloatType::get); py::class_>(m, "DynamicType") .def_static("get", &DynamicType::get); + py::class_>(m, "BoolType") + .def_static("get", &BoolType::get); py::class_>(m, "TupleType") .def(py::init([](std::vector a){ return TupleType::create(a); })) diff --git a/torch/csrc/jit/register_prim_ops.cpp b/torch/csrc/jit/register_prim_ops.cpp index cdea4ab894b253..c7bf050dc2738c 100644 --- a/torch/csrc/jit/register_prim_ops.cpp +++ b/torch/csrc/jit/register_prim_ops.cpp @@ -69,6 +69,17 @@ RegisterOperators reg({ return 0; }; }), + Operator( + prim::TensorToBool, + [](Node* node) -> Operation { + return [](Stack& stack) { + at::Tensor a; + pop(stack, a); + at::DeviceGuard guard(a); + push(stack, a.item() != 0); + return 0; + }; + }), Operator( prim::TensorToNum, [](Node* node) -> Operation { @@ -123,6 +134,18 @@ RegisterOperators reg({ return 0; }; }), + Operator( + prim::BoolToTensor, + [](Node* node) -> Operation { + return [](Stack& stack) { + bool b; + pop(stack, b); + push( + stack, + autograd::make_variable(at::scalar_to_tensor(b))); + return 0; + }; + }), Operator( prim::IntToFloat, [](Node* node) -> Operation { @@ -446,25 +469,25 @@ RegisterOperators reg({ }); // define implementations for primitive number ops -#define DEFINE_GENERIC_OP(aten_op, int_op, float_op, float_result) \ - Operator( \ - #aten_op "(int a, int b) -> int", \ - [](Node* node) { \ - return [=](Stack& stack) { \ - int64_t a, b; \ - pop(stack, a, b); \ - push(stack, int_op); \ - return 0; \ - }; \ - }), \ - Operator( \ - #aten_op "(float a, float b) -> " #float_result, [](Node* node) { \ - return [=](Stack& stack) { \ - double a, b; \ - pop(stack, a, b); \ - push(stack, float_op); \ - return 0; \ - }; \ +#define DEFINE_GENERIC_OP(aten_op, int_op, float_op, int_result, float_result) \ + Operator( \ + #aten_op "(int a, int b) -> " #int_result, \ + [](Node* node) { \ + return [=](Stack& stack) { \ + int64_t a, b; \ + pop(stack, a, b); \ + push(stack, int_op); \ + return 0; \ + }; \ + }), \ + Operator( \ + #aten_op "(float a, float b) -> " #float_result, [](Node* node) { \ + return [=](Stack& stack) { \ + double a, b; \ + pop(stack, a, b); \ + push(stack, float_op); \ + return 0; \ + }; \ }), #define DEFINE_INT_OP(aten_op, op) \ @@ -477,8 +500,19 @@ RegisterOperators reg({ }; \ }), -#define DEFINE_BINARY_OP(aten_op, op) DEFINE_GENERIC_OP(aten_op, op, op, float) -#define DEFINE_COMPARISON_OP(aten_op, op) DEFINE_GENERIC_OP(aten_op, op, op, int) +#define DEFINE_BINARY_OP(aten_op, op) \ + DEFINE_GENERIC_OP(aten_op, op, op, int, float) +#define DEFINE_COMPARISON_OP(aten_op, op) \ + DEFINE_GENERIC_OP(aten_op, op, op, bool, bool) +#define DEFINE_BOOL_OP(aten_op, op) \ + Operator(#aten_op "(bool a, bool b) -> bool", [](Node* node) { \ + return [=](Stack& stack) { \ + bool a, b; \ + pop(stack, a, b); \ + push(stack, op); \ + return 0; \ + }; \ + }), // Convert an python index (which may be negative) into an index usable for a // C++ container @@ -663,7 +697,7 @@ RegisterOperators reg2({ // Pass in two ops for handling int and float separately as % in C++ only works for int // The modulus calculation is different between C++ and Python (on negative), we preserve // the python behavior as it's more common and match python syntax, hence the conversion. - DEFINE_GENERIC_OP(aten::remainder, (b + (a % b)) % b, fmod((b + fmod(a, b)), b), float) + DEFINE_GENERIC_OP(aten::remainder, (b + (a % b)) % b, fmod((b + fmod(a, b)), b), int, float) // TODO: Support python floordiv (//) // Right now aten::floordiv is only used by loop unrolling @@ -696,8 +730,8 @@ RegisterOperators reg2({ DEFINE_COMPARISON_OP(aten::le, a <= b) DEFINE_COMPARISON_OP(aten::ge, a >= b) - DEFINE_INT_OP(aten::__and__, a&& b) - DEFINE_INT_OP(aten::__or__, a || b) + DEFINE_BOOL_OP(aten::__and__, a && b) + DEFINE_BOOL_OP(aten::__or__, a || b) Operator("aten::_construct_empty_int_list() -> int[]", [](Node* node) -> Operation { diff --git a/torch/csrc/jit/script/compiler.cpp b/torch/csrc/jit/script/compiler.cpp index 28aa735fc37249..474722f5362031 100644 --- a/torch/csrc/jit/script/compiler.cpp +++ b/torch/csrc/jit/script/compiler.cpp @@ -74,6 +74,8 @@ static Value* typeCast(const SourceRange& loc, Value* value, TypePtr dst) { n = graph.createNumToTensor(value); } else if (dst->isSubtypeOf(NumberType::get()) && orig->isSubtypeOf(DynamicType::get())) { n = graph.createTensorToNum(dst, value); + } else if (dst->isSubtypeOf(BoolType::get()) && orig->isSubtypeOf(DynamicType::get())) { + n = graph.createTensorToBool(value); } else if(dst->isSubtypeOf(IntType::get()) && orig->isSubtypeOf(FloatType::get())) { n = graph.createFloatToInt(value); } else if(dst->isSubtypeOf(FloatType::get()) && orig->isSubtypeOf(IntType::get())) { @@ -324,7 +326,7 @@ struct Environment { {"print", std::make_shared()}, {"float", std::make_shared(FloatType::get())}, {"int", std::make_shared(IntType::get())}, - {"bool", std::make_shared(IntType::get())}, + {"bool", std::make_shared(BoolType::get())}, // todo(zach): remove when we can correctly export torch.full via ONNX // or we have implicit conversion that can convert numbers to tensors {"_to_tensor", std::make_shared(DynamicType::get()) }, @@ -1048,9 +1050,9 @@ struct to_ir { Value* emitCond(Expr cond) { Value* v = emitExpr(cond); - if (!v->type()->isSubtypeOf(IntType::get())) { + if (!v->type()->isSubtypeOf(BoolType::get())) { ErrorReport error(cond); - error << "expected an integer expression for condition but found " + error << "expected a boolean expression for condition but found " << v->type()->str(); if (v->type()->isSubtypeOf(DynamicType::get())) { error << ", to use a tensor in a boolean" @@ -1928,6 +1930,7 @@ const std::unordered_map &ident_to_type_lut() { {"Tensor", DynamicType::get()}, {"int", IntType::get()}, {"float", FloatType::get()}, + {"bool", BoolType::get()}, }; return map; } diff --git a/torch/csrc/jit/script/init.cpp b/torch/csrc/jit/script/init.cpp index 4c7df820b13b4f..fec69ac317789c 100644 --- a/torch/csrc/jit/script/init.cpp +++ b/torch/csrc/jit/script/init.cpp @@ -278,12 +278,12 @@ std::shared_ptr toSugaredValue( // f = f + 1 auto& g = *m.graph(); if (is_constant) { - if (py::isinstance(obj)) { + if (py::isinstance(obj)) { + return toSimple(g.insertConstant(py::cast(obj), loc)); + } else if (py::isinstance(obj)) { return toSimple(g.insertConstant(py::cast(obj), loc)); } else if (py::isinstance(obj)) { return toSimple(g.insertConstant(py::cast(obj), loc)); - } else if (py::isinstance(obj)) { - return toSimple(g.insertConstant(py::cast(obj), loc)); } else if (THPDevice_Check(obj.ptr())) { auto device = (THPDevice*)obj.ptr(); std::vector v = {static_cast(device->device.type()), diff --git a/torch/csrc/jit/type.cpp b/torch/csrc/jit/type.cpp index 855adad429191f..ce3cd8c1f225f2 100644 --- a/torch/csrc/jit/type.cpp +++ b/torch/csrc/jit/type.cpp @@ -46,6 +46,8 @@ std::ostream& operator<<(std::ostream & out, const Type & t) { out << "float"; } else if(t.kind() == TypeKind::IntType) { out << "int"; + } else if(t.kind() == TypeKind::BoolType) { + out << "bool"; } else if(t.kind() == TypeKind::ListType) { auto prim = t.cast()->getElementType(); out << *prim << "[]"; @@ -85,6 +87,10 @@ FloatTypePtr FloatType::get() { static auto value = FloatType::create(); return value; } +BoolTypePtr BoolType::get() { + static auto value = BoolType::create(); + return value; +} NoneTypePtr NoneType::get() { static auto value = NoneType::create(); return value; @@ -113,6 +119,10 @@ ListTypePtr ListType::ofFloats() { static auto value = ListType::create(FloatType::get()); return value; } +ListTypePtr ListType::ofBools() { + static auto value = ListType::create(BoolType::get()); + return value; +} TypePtr inferTypeFrom(const IValue& value) { if (value.isTensor()) { @@ -121,12 +131,16 @@ TypePtr inferTypeFrom(const IValue& value) { return FloatType::get(); } else if (value.isInt()) { return IntType::get(); + } else if (value.isBool()) { + return BoolType::get(); } else if (value.isString()) { return StringType::get(); } else if (value.isIntList()) { return ListType::ofInts(); } else if (value.isTensorList()) { return ListType::ofTensors(); + } else if (value.isBoolList()) { + return ListType::ofBools(); } else if (value.isDoubleList()) { return ListType::ofFloats(); } else if (value.isTuple()) { diff --git a/torch/csrc/jit/type.h b/torch/csrc/jit/type.h index 49748de239e2b2..69133f6be9c3a6 100644 --- a/torch/csrc/jit/type.h +++ b/torch/csrc/jit/type.h @@ -27,6 +27,7 @@ _(IntType) \ _(NoneType) \ _(StringType) \ _(GeneratorType) \ +_(BoolType) \ _(VarType) \ _(WorldType) \ @@ -343,6 +344,7 @@ struct TORCH_API CompleteTensorType : public TensorType { return prod; } static TypePtr fromNumberType(TypePtr typ); + static TypePtr fromBoolType(); private: CompleteTensorType(const at::Tensor& tensor) @@ -438,6 +440,7 @@ struct TORCH_API ListType : public Type { static ListTypePtr ofTensors(); static ListTypePtr ofInts(); static ListTypePtr ofFloats(); + static ListTypePtr ofBools(); static const TypeKind Kind = TypeKind::ListType; private: @@ -605,6 +608,31 @@ struct TORCH_API IntType : public Type { : Type(TypeKind::IntType) {} }; +struct BoolType; +using BoolTypePtr = std::shared_ptr; +// This node represents a Python bool value +struct TORCH_API BoolType : public Type { + template + static BoolTypePtr create( T&& ... all ) { + return BoolTypePtr(new BoolType(std::forward(all)... )); + } + bool operator==(const Type& rhs) const override { + return rhs.kind() == kind(); + } + std::string str() const override { + return "bool"; + } + bool isSubtypeOf(const TypePtr rhs) const override { + return *this == *rhs || rhs->kind() == TypeKind::BoolType; + } + static const TypeKind Kind = TypeKind::BoolType; + // global singleton + static BoolTypePtr get(); +private: + BoolType() + : Type(TypeKind::BoolType) {} +}; + struct StringType; using StringTypePtr = std::shared_ptr; // This node represents a Python string value @@ -728,10 +756,17 @@ inline TypePtr CompleteTensorType::fromNumberType(TypePtr typ) { return CompleteTensorType::create(at::kLong, -1, {}); } else if (typ->isSubtypeOf(FloatType::get())) { return CompleteTensorType::create(at::kFloat, -1, {}); + } else if (typ->isSubtypeOf(BoolType::get())) { + return CompleteTensorType::create(at::kLong, -1, {}); } AT_ERROR("unknown number type", typ->str()); } +inline TypePtr CompleteTensorType::fromBoolType() { + return CompleteTensorType::create(at::kLong, -1, {}); +} + + // Attempt to find the correct supertype of t1 and t2. If none is found then // nullopt will be returned. If t1 == t2, or t1 is a type refinement of t2, // then t2 will be returned (and vice versa). @@ -755,7 +790,7 @@ TypePtr getTypePtr() { template<> inline TypePtr getTypePtr() { return DynamicType::get(); } template<> inline TypePtr getTypePtr() { return FloatType::get(); } template<> inline TypePtr getTypePtr() { return IntType::get(); } -template<> inline TypePtr getTypePtr() { return IntType::get(); } +template<> inline TypePtr getTypePtr() { return BoolType::get(); } template<> inline TypePtr getTypePtr() { return NumberType::get(); } template<> inline TypePtr getTypePtr>() { return ListType::ofTensors(); } template<> inline TypePtr getTypePtr>() { return ListType::ofFloats(); } diff --git a/torch/jit/batchop.py b/torch/jit/batchop.py index 229cafbb94119d..fed8d2a7c60599 100644 --- a/torch/jit/batchop.py +++ b/torch/jit/batchop.py @@ -214,8 +214,8 @@ def batch_where(data, mask, dims, data1, mask1, dims1, data2, mask2, dims2): @torch.jit.script -def batch_where_scalar(cond_, data1, mask1, dims1, data2, mask2, dims2): - cond = torch.zeros([1], dtype=torch.uint8) * cond_ +def batch_where_scalar(cond, data1, mask1, dims1, data2, mask2, dims2): + cond = torch.zeros([1], dtype=torch.uint8) res_data = torch.where(cond, data1, data2) res_mask = torch.where(cond, mask1, mask2) res_dims = torch.where(cond, dims1, dims2) @@ -304,7 +304,7 @@ def batch_unsqueeze(data, mask, dims, dim_): @torch.jit.script def batch_argmax(data, mask, dims, dim_, keepdim_): dim = int(dim_) - keepdim = int(keepdim_) + keepdim = bool(keepdim_) # if dim == 0: # raise ValueError("cannot do argmax along batch_dim") batch_size = data.size(0) @@ -338,8 +338,8 @@ def batch_argmax(data, mask, dims, dim_, keepdim_): def batch_topk(data, mask, dims, k_, dim_, largest_, sorted_): k = int(k_) dim = int(dim_) - largest = int(largest_) - sorted = int(sorted_) + largest = bool(largest_) + sorted = bool(sorted_) # if dim == 0: # raise ValueError("cannot do topk along batch_dim") batch_size = data.size(0) diff --git a/torch/onnx/symbolic.py b/torch/onnx/symbolic.py index eae2e7fe2cdab3..7295b56150c0f5 100644 --- a/torch/onnx/symbolic.py +++ b/torch/onnx/symbolic.py @@ -959,10 +959,6 @@ def _cast_func_template(to_i, g, input, non_blocking): globals()[name] = parse_args('v', 'i')(partial(_cast_func_template, v)) -def zeros_like(g, input): - return g.op("Sub", input, input).setType(input.type().contiguous()) - - scalar_type_to_onnx = [ cast_pytorch_to_onnx["Byte"], cast_pytorch_to_onnx["Char"], @@ -976,20 +972,28 @@ def zeros_like(g, input): @parse_args('v', 'i', 'v', 'v') -def zeros(g, shape, scalar_type, layout, device): - # NOTE: no way to set device in ONNX, so we ignore it - return g.op("ConstantFill", shape, dtype_i=scalar_type_to_onnx[scalar_type], - input_as_shape_i=1, value_f=0) +def zeros(g, sizes, dtype, layout, device): + # NOTE: no way to set device and layout in ONNX, so we ignore it + return g.op("ConstantFill", sizes, dtype_i=scalar_type_to_onnx[dtype], input_as_shape_i=1, value_f=0) + + +def zeros_like(g, input): + return g.op("Sub", input, input).setType(input.type().contiguous()) + + +@parse_args('v', 'i', 'v', 'v') +def ones(g, sizes, dtype, layout, device): + return g.op("ConstantFill", sizes, dtype_i=scalar_type_to_onnx[dtype], input_as_shape_i=1, value_f=1) -def full(g, shape, value, scalar_type, layout, device): +def full(g, sizes, value, dtype, layout, device): const_value = _maybe_get_const(value, 't') if _is_value(const_value): - tmp = zeros(shape, scalar_type, layout, device) + tmp = zeros(sizes, dtype, layout, device) return add(tmp, value, g.op("Constant", value_t=torch.tensor(1))) else: - scalar_type = _get_const(scalar_type, 'i', 'dtype') - return g.op("ConstantFill", shape, dtype_i=scalar_type_to_onnx[scalar_type], + dtype = _get_const(dtype, 'i', 'dtype') + return g.op("ConstantFill", sizes, dtype_i=scalar_type_to_onnx[dtype], input_as_shape_i=1, value_f=const_value)