FM / cpu

/usr/local/lib64/python3.6/site-packages/torch/include/ATen/native/cpu/

/usr/local/lib64/python3.6/site-packages/torch/include/ATen/native/cpu

Name	Size	Mode	Actions
AtomicAddFloat.h	750	0644	edit dl rm
avx_mathfun.h	17448	0644	edit dl rm
CatKernel.h	252	0644	edit dl rm
DepthwiseConvKernel.h	447	0644	edit dl rm
DistributionTemplates.h	14051	0644	edit dl rm
GridSamplerKernel.h	592	0644	edit dl rm
Intrinsics.h	1212	0644	edit dl rm
IsContiguous.h	2414	0644	edit dl rm
Loops.h	14411	0644	edit dl rm
MaxUnpoolKernel.h	483	0644	edit dl rm
moments_utils.h	4245	0644	edit dl rm
Reduce.h	10955	0644	edit dl rm
SoftmaxKernel.h	636	0644	edit dl rm
StackKernel.h	315	0644	edit dl rm
utils.h	1093	0644	edit dl rm
zmath.h	6480	0644	edit dl rm

Edit: /usr/local/lib64/python3.6/site-packages/torch/include/ATen/native/cpu/IsContiguous.h (2414B)

#pragma once

namespace at { namespace native { namespace {

// n: number of function arguments (arity)
// traits: function_traits (see FunctionTraits.h)
// s: index of scalar argument or -1
template <int n, int stride_index, typename traits, int s=-1>
struct IsContiguous {
  static bool eval(const int64_t* strides) {
    using type = typename traits::template arg<n - 1>::type;
    return strides[stride_index] == (s == n ? 0 : sizeof(type)) &&
           IsContiguous<n - 1, stride_index - 1, traits, s>::eval(strides);
  }
};

// will be called when there is an output exists
template <typename traits, int s>
struct IsContiguous<0, 0, traits, s> {
  static bool eval(const int64_t* strides) {
    return strides[0] == sizeof(typename traits::result_type);
  }
};

// will be called when there is no output
template <typename traits, int s>
struct IsContiguous<0, -1, traits, s> {
  static bool eval(const int64_t* strides) {
    return true;
  }
};

// output and all inputs are contiguous
template <typename traits,
    typename std::enable_if<std::is_void<typename traits::result_type>::value>::type* = nullptr>
static inline bool is_contiguous(const int64_t* strides) {
  return IsContiguous<traits::arity, traits::arity - 1, traits>::eval(strides);
}

template <typename traits,
    typename std::enable_if<!std::is_void<typename traits::result_type>::value>::type* = nullptr>
static inline bool is_contiguous(const int64_t* strides) {
  return IsContiguous<traits::arity, traits::arity, traits>::eval(strides);
}

// input at `s` is scalar (stride 0); output and other inputs are contiguous
// NB: output is typically at strides[0] so first input corresponds to s=1
template <typename traits, int s,
    typename std::enable_if<std::is_void<typename traits::result_type>::value>::type* = nullptr>
static inline bool is_contiguous_scalar(const int64_t* strides) {
  static_assert(s > 0 && s <= traits::arity, "scalar argument index out of bounds");
  return IsContiguous<traits::arity, traits::arity - 1, traits, s>::eval(strides);
}

template <typename traits, int s,
    typename std::enable_if<!std::is_void<typename traits::result_type>::value>::type* = nullptr>
static inline bool is_contiguous_scalar(const int64_t* strides) {
  static_assert(s > 0 && s <= traits::arity, "scalar argument index out of bounds");
  return IsContiguous<traits::arity, traits::arity, traits, s>::eval(strides);
}

}}}

#pragma once namespace at { namespace native { namespace { // n: number of function arguments (arity) // traits: function_traits (see FunctionTraits.h) // s: index of scalar argument or -1 template struct IsContiguous { static bool eval(const int64_t* strides) { using type = typename traits::template arg::type; return strides[stride_index] == (s == n ? 0 : sizeof(type)) && IsContiguous::eval(strides); } }; // will be called when there is an output exists template struct IsContiguous<0, 0, traits, s> { static bool eval(const int64_t* strides) { return strides[0] == sizeof(typename traits::result_type); } }; // will be called when there is no output template struct IsContiguous<0, -1, traits, s> { static bool eval(const int64_t* strides) { return true; } }; // output and all inputs are contiguous template ::value>::type* = nullptr> static inline bool is_contiguous(const int64_t* strides) { return IsContiguous::eval(strides); } template ::value>::type* = nullptr> static inline bool is_contiguous(const int64_t* strides) { return IsContiguous::eval(strides); } // input at `s` is scalar (stride 0); output and other inputs are contiguous // NB: output is typically at strides[0] so first input corresponds to s=1 template ::value>::type* = nullptr> static inline bool is_contiguous_scalar(const int64_t* strides) { static_assert(s > 0 && s <= traits::arity, "scalar argument index out of bounds"); return IsContiguous::eval(strides); } template ::value>::type* = nullptr> static inline bool is_contiguous_scalar(const int64_t* strides) { static_assert(s > 0 && s <= traits::arity, "scalar argument index out of bounds"); return IsContiguous::eval(strides); } }}}