/usr/local/lib64/python3.6/site-packages/torch/include/ATen
Edit: /usr/local/lib64/python3.6/site-packages/torch/include/ATen/Utils.h (5993B)
#pragma once
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#define AT_DISALLOW_COPY_AND_ASSIGN(TypeName) \
TypeName(const TypeName&) = delete; \
void operator=(const TypeName&) = delete
namespace at {
TORCH_API int _crash_if_asan(int);
// TODO: This unwrapping code is ONLY used for TH bindings; once TH goes
// away, we can delete this function
static inline TensorImpl* checked_dense_tensor_unwrap(const Tensor& expr, const char * name, int pos, const char * api, bool allowNull, DeviceType device_type, ScalarType scalar_type) {
if(allowNull && !expr.defined()) {
return nullptr;
}
if (expr.layout() != Layout::Strided) {
AT_ERROR("Expected dense tensor but got ", expr.layout(),
" for argument #", pos, " '", name, "' in call to ", api);
}
if (expr.device().type() != device_type) {
AT_ERROR("Expected object of device type ", device_type, " but got device type ", expr.device().type(),
" for argument #", pos, " '", name, "' in call to ", api);
}
if (expr.scalar_type() != scalar_type) {
AT_ERROR("Expected object of scalar type ", scalar_type, " but got scalar type ", expr.scalar_type(),
" for argument #", pos, " '", name, "' in call to ", api);
}
return expr.unsafeGetTensorImpl();
}
// Converts a TensorList (i.e. ArrayRef to vector of TensorImpl*)
// NB: This is ONLY used by legacy TH bindings, and ONLY used by cat.
// Once cat is ported entirely to ATen this can be deleted!
static inline std::vector checked_dense_tensor_list_unwrap(ArrayRef tensors, const char * name, int pos, DeviceType device_type, ScalarType scalar_type) {
std::vector unwrapped;
unwrapped.reserve(tensors.size());
for (const auto i : c10::irange(tensors.size())) {
const auto& expr = tensors[i];
if (expr.layout() != Layout::Strided) {
AT_ERROR("Expected dense tensor but got ", expr.layout(),
" for sequence element ", i , " in sequence argument at position #", pos, " '", name, "'");
}
if (expr.device().type() != device_type) {
AT_ERROR("Expected object of device type ", device_type, " but got device type ", expr.device().type(),
" for sequence element ", i , " in sequence argument at position #", pos, " '", name, "'");
}
if (expr.scalar_type() != scalar_type) {
AT_ERROR("Expected object of scalar type ", scalar_type, " but got scalar type ", expr.scalar_type(),
" for sequence element ", i , " in sequence argument at position #", pos, " '", name, "'");
}
unwrapped.emplace_back(expr.unsafeGetTensorImpl());
}
return unwrapped;
}
template
std::array check_intlist(ArrayRef list, const char * name, int pos) {
if (list.empty()) {
// TODO: is this necessary? We used to treat nullptr-vs-not in IntList differently
// with strides as a way of faking optional.
list = {};
}
auto res = std::array();
if (list.size() == 1 && N > 1) {
res.fill(list[0]);
return res;
}
if (list.size() != N) {
AT_ERROR("Expected a list of ", N, " ints but got ", list.size(), " for argument #", pos, " '", name, "'");
}
std::copy_n(list.begin(), N, res.begin());
return res;
}
/**
* Utility function to static cast input Generator* to
* the backend generator type (CPU/CUDAGeneratorImpl etc.)
*/
template
static inline T * check_generator(c10::optional gen) {
TORCH_CHECK(gen.has_value(), "Expected Generator but received nullopt");
TORCH_CHECK(gen->defined(), "Generator with undefined implementation is not allowed");
TORCH_CHECK(T::device_type() == gen->device().type(), "Expected a '", T::device_type(), "' device type for generator but found '", gen->device().type(), "'");
return gen->get();
}
/**
* Utility function used in tensor implementations, which
* supplies the default generator to tensors, if an input generator
* is not supplied. The input Generator* is also static casted to
* the backend generator type (CPU/CUDAGeneratorImpl etc.)
*/
template
static inline T* get_generator_or_default(const c10::optional& gen, const Generator& default_gen) {
return gen.has_value() && gen->defined() ? check_generator(gen) : check_generator(default_gen);
}
inline void check_size_nonnegative(IntArrayRef size) {
for (auto x: size) {
TORCH_CHECK(x >= 0, "Trying to create tensor with negative dimension ", x, ": ", size);
}
}
namespace detail {
TORCH_API
Tensor empty_cpu(IntArrayRef size, c10::optional dtype_opt, c10::optional layout_opt,
c10::optional device_opt, c10::optional pin_memory_opt, c10::optional memory_format_opt);
TORCH_API
Tensor empty_generic(
IntArrayRef size,
c10::Allocator* allocator,
// technically this can be inferred from the device, but usually the
// correct setting is obvious from the call site so just make callers
// pass it in
c10::DispatchKey dispatch_key,
ScalarType dtype,
Device device,
c10::optional memory_format
);
template
TORCH_API
Tensor tensor_cpu(ArrayRef values, const TensorOptions& options);
template
TORCH_API
Tensor tensor_backend(ArrayRef values, const TensorOptions& options);
template
TORCH_API
Tensor tensor_complex_cpu(ArrayRef values, const TensorOptions& options);
template
TORCH_API
Tensor tensor_complex_backend(ArrayRef values, const TensorOptions& options);
} // namespace detail
} // at