Convert all tabs to spaces, add CI. (pytorch#18959)

Summary:
Pull Request resolved: pytorch#18959
ghimport-source-id: a934163

Differential Revision: D14831246

Pulled By: ezyang

fbshipit-source-id: beb92dc4ee8c82f4c8259c081dd72e477fe7a9d0

.travis.yml

@@ -16,6 +16,10 @@ matrix:
         python: "3.6"
         dist: xenial
         script: cd .circleci && ./ensure-consistency.py
+      - name: "Ensure no tabs"
+        python: "2.7"
+        script:
+          - (! git grep -I -l $'\t' -- . ':(exclude)*.svg' ':(exclude)**Makefile' ':(exclude)**/contrib/**' ':(exclude)third_party' ':(exclude).gitattributes' ':(exclude).gitmodules' || (echo "The above files have tabs; please convert them to spaces"; false))
       - name: "Python 2.7 Lint"
         python: "2.7"
         install: pip install flake8

aten/src/ATen/CMakeLists.txt

@@ -252,21 +252,21 @@ IF(USE_CUDA AND NOT USE_ROCM)
     EXECUTE_PROCESS(COMMAND touch ${CMAKE_CURRENT_BINARY_DIR}/empty_file.cc)
     if(${CUDA_VERSION_MAJOR} EQUAL "8")
       SET(CUFFT_FAKELINK_OPTIONS
-	--generate-code arch=compute_35,code=sm_35
-	--generate-code arch=compute_50,code=sm_50
-	--generate-code arch=compute_60,code=sm_60)
+        --generate-code arch=compute_35,code=sm_35
+        --generate-code arch=compute_50,code=sm_50
+        --generate-code arch=compute_60,code=sm_60)
     elseif(${CUDA_VERSION_MAJOR} EQUAL "9")
       SET(CUFFT_FAKELINK_OPTIONS
-	--generate-code arch=compute_35,code=sm_35
-	--generate-code arch=compute_50,code=sm_50
-	--generate-code arch=compute_60,code=sm_60
-	--generate-code arch=compute_70,code=sm_70)
+        --generate-code arch=compute_35,code=sm_35
+        --generate-code arch=compute_50,code=sm_50
+        --generate-code arch=compute_60,code=sm_60
+        --generate-code arch=compute_70,code=sm_70)
     elseif(${CUDA_VERSION_MAJOR} EQUAL "10")
       SET(CUFFT_FAKELINK_OPTIONS
-	--generate-code arch=compute_35,code=sm_35
-	--generate-code arch=compute_50,code=sm_50
-	--generate-code arch=compute_60,code=sm_60
-	--generate-code arch=compute_70,code=sm_70)
+        --generate-code arch=compute_35,code=sm_35
+        --generate-code arch=compute_50,code=sm_50
+        --generate-code arch=compute_60,code=sm_60
+        --generate-code arch=compute_70,code=sm_70)
     else()
       MESSAGE(FATAL_ERROR "Unhandled major cuda version ${CUDA_VERSION_MAJOR}")
     endif()

aten/src/ATen/cpu/vec256/intrinsics.h

@@ -19,7 +19,7 @@
 /* GCC-compatible compiler, targeting ARM with WMMX */
 #include <mmintrin.h>
 #elif (defined(__GNUC__) || defined(__xlC__)) &&                               \
-	(defined(__VEC__) || defined(__ALTIVEC__))
+        (defined(__VEC__) || defined(__ALTIVEC__))
 /* XLC or GCC-compatible compiler, targeting PowerPC with VMX/VSX */
 #include <altivec.h>
 #elif defined(__GNUC__) && defined(__SPE__)

aten/src/ATen/native/Linear.cpp

@@ -46,12 +46,12 @@ static Tensor sumproduct_pair(const Tensor& left_, const Tensor& right_, IntArra
     auto sr = right.size(i)>1;
     if (sum_dims[i]) { // first dimensions that will be summed over after multiplication
       if (sl && sr) {  // dimensions nontrivially in both left and right must be of the same size
-	AT_CHECK(left.size(i)==right.size(i), "non-broadcast dimensions must match");
-	sum_size *= left.size(i);
+        AT_CHECK(left.size(i)==right.size(i), "non-broadcast dimensions must match");
+        sum_size *= left.size(i);
       } else if (sl) { // if it is only in one of left and right, we can sum right away
-	left = left.sum(i, true);
+        left = left.sum(i, true);
       } else if (sr) {
-	right = right.sum(i, true);
+        right = right.sum(i, true);
       }
     } else if (sl && sr) { // now deal with dimensions  dimensions that will be in the output
       // dimensions nontrivially in both left and right must be of the same size
@@ -117,7 +117,7 @@ static Tensor sumproduct_pair(const Tensor& left_, const Tensor& right_, IntArra
   if (! keepdim) {
     for (int i = dim-1; i>=0; i--)
       if (sum_dims[i])
-	result.squeeze_(i);
+        result.squeeze_(i);
   }
   return result;
 }
@@ -183,7 +183,7 @@ Tensor einsum(std::string eqn, TensorList tensors) {
           }
           else {                          // we have seen an ellipsis before, so we check compatibility
             AT_CHECK(candidate_num_ell_idxes == num_ell_idxes,
-		     "ellipsis must represent ", num_ell_idxes, " dimensions in all terms");
+                     "ellipsis must represent ", num_ell_idxes, " dimensions in all terms");
           }
           for (int64_t i = 0; i < num_ell_idxes; ++i) { // map ellipsis dimensions in operand to indices
             current_op_idxes.push_back(first_ell_idx + i);
@@ -360,8 +360,8 @@ Tensor einsum(std::string eqn, TensorList tensors) {
 // the computation is unrolled in the unroll_dim dimension
 // its main purpose is to unify the computations in bilinear and bilinear_backward
 Tensor _trilinear(const Tensor& i1_, const Tensor& i2_, const Tensor& i3_,
-		  IntArrayRef expand1_, IntArrayRef expand2_, IntArrayRef expand3_,
-		  IntArrayRef sumdim_, int64_t unroll_dim) {
+                  IntArrayRef expand1_, IntArrayRef expand2_, IntArrayRef expand3_,
+                  IntArrayRef sumdim_, int64_t unroll_dim) {
   int64_t total_dim = i1_.dim()+expand1_.size();
   AT_CHECK((unroll_dim >= 0) && (unroll_dim < total_dim), "unroll_dim must be in [0,", total_dim-1, "]");
   auto expand1 = at::dim_list_to_bitset(expand1_, total_dim);
@@ -390,11 +390,11 @@ Tensor _trilinear(const Tensor& i1_, const Tensor& i2_, const Tensor& i3_,
     if (expand3[i]) {
       i3 = i3.unsqueeze(i);
       if (sumdim[i] && (i != unroll_dim))
-	sum_dims_12.push_back(i);
+        sum_dims_12.push_back(i);
     } else  {
       s = i3.size(i);
       if (sumdim[i] && (i != unroll_dim))
-	sum_dims_23.push_back(i);
+        sum_dims_23.push_back(i);
     }
     output_size.push_back(sumdim[i] ? 1 : s);
     if (i == unroll_dim)
@@ -408,16 +408,16 @@ Tensor _trilinear(const Tensor& i1_, const Tensor& i2_, const Tensor& i3_,
   if (! sumdim[unroll_dim]) {
     for (int64_t k = 0; k < unroll_size; k++) {
       Tensor buf = at::native::sumproduct_pair(i1.narrow(unroll_dim, k * slicemul1, 1),
-					       i2.narrow(unroll_dim, k * slicemul2, 1),
-					       sum_dims_12, true);
+                                               i2.narrow(unroll_dim, k * slicemul2, 1),
+                                               sum_dims_12, true);
       buf = at::native::sumproduct_pair(buf, i3.narrow(unroll_dim, k * slicemul3, 1), sum_dims_23, true);
       output.narrow(unroll_dim, k, 1).add_(buf);
     }
   }
   else {
     for (int64_t k = 0; k < unroll_size; k++) {
       Tensor buf = at::native::sumproduct_pair(i1.narrow(unroll_dim, k*slicemul1, 1),
-					       i2.narrow(unroll_dim, k*slicemul2, 1), sum_dims_12, true);
+                                               i2.narrow(unroll_dim, k*slicemul2, 1), sum_dims_12, true);
       buf = at::native::sumproduct_pair(buf, i3.narrow(unroll_dim, k*slicemul3, 1), sum_dims_23, true);
       output.add_(buf);
     }
@@ -473,7 +473,7 @@ Tensor tensordot(const Tensor& input1, const Tensor& input2, IntArrayRef dims1,
       t2 = t2.sum(dims2[i], true);
     } else {
       AT_CHECK(s1 == s2, "contracted dimensions need to match, but first has size ", s1, " in dim ", dims1[i],
-	       " and second has size ", s2, " in dim ", dims2[i]);
+               " and second has size ", s2, " in dim ", dims2[i]);
       csize *= s1;
     }
   }

aten/src/ATen/native/LossCTC.cpp

@@ -61,7 +61,7 @@ std::tuple<Tensor, Tensor> ctc_loss_cpu_template(const Tensor& log_probs, const
       tg_batch_offsets[i] = pos;
       pos += target_lengths[i];
       if (max_target_length < target_lengths[i])
-	 max_target_length = target_lengths[i];
+         max_target_length = target_lengths[i];
     }
     tg_target_stride = targets.stride(0);
     checkSize(c, targets_arg, 0, pos);
@@ -83,8 +83,8 @@ std::tuple<Tensor, Tensor> ctc_loss_cpu_template(const Tensor& log_probs, const
   int64_t max_input_length = log_probs.size(0);
   for (int64_t b = 0; b < batch_size; b++) {
     AT_CHECK(input_lengths[b] <= max_input_length,
-	     "Expected tensor to have size at least ", max_input_length, " at dimension 1, but got size ", input_lengths[b], " for ", log_probs_arg,
-	     " (while checking arguments for ", c, ")");
+             "Expected tensor to have size at least ", max_input_length, " at dimension 1, but got size ", input_lengths[b], " for ", log_probs_arg,
+             " (while checking arguments for ", c, ")");
   }
 
   Tensor log_alpha = at::empty({batch_size, log_probs.size(0), 2*max_target_length+1}, log_probs.options());
@@ -115,11 +115,11 @@ std::tuple<Tensor, Tensor> ctc_loss_cpu_template(const Tensor& log_probs, const
     // now the loop over the inputs
     for (int64_t t=1; t<input_length; t++) {
       for (int64_t s=0; s<2*target_length+1; s++) {
-	auto current_target_prime = get_target_prime(targets_data, tg_batch_offset, tg_target_stride, s, BLANK);
-	// this loop over s could be parallel/vectorized, too, but the required items are one index apart
-	// alternatively, one might consider moving s to the outer loop to cache current_target_prime more (but then it needs to be descending)
-	// for the cuda implementation, that gave a speed boost.
-	// This is eq (6) and (7), la1,2,3 are the three summands. We keep track of the maximum for the logsumexp calculation.
+        auto current_target_prime = get_target_prime(targets_data, tg_batch_offset, tg_target_stride, s, BLANK);
+        // this loop over s could be parallel/vectorized, too, but the required items are one index apart
+        // alternatively, one might consider moving s to the outer loop to cache current_target_prime more (but then it needs to be descending)
+        // for the cuda implementation, that gave a speed boost.
+        // This is eq (6) and (7), la1,2,3 are the three summands. We keep track of the maximum for the logsumexp calculation.
 
         scalar_t la1 = log_alpha_a[t-1][s];
         scalar_t lamax = la1;
@@ -141,7 +141,7 @@ std::tuple<Tensor, Tensor> ctc_loss_cpu_template(const Tensor& log_probs, const
         }
         if (lamax == neginf) // cannot do neginf-neginf
           lamax = 0;
-	// this is the assignment of eq (6)
+        // this is the assignment of eq (6)
         log_alpha_a[t][s] = std::log(std::exp(la1-lamax)+std::exp(la2-lamax)+std::exp(la3-lamax))+lamax + log_probs_a[t][current_target_prime];
       }
     }
@@ -182,7 +182,7 @@ Tensor ctc_loss_backward_cpu_template(const Tensor& grad_out, const Tensor& log_
       tg_batch_offsets[i] = pos;
       pos += target_lengths[i];
       if (max_target_length < target_lengths[i])
-	max_target_length = target_lengths[i];
+        max_target_length = target_lengths[i];
     }
     tg_target_stride = targets.stride(0);
   }
@@ -268,9 +268,9 @@ Tensor ctc_loss_backward_cpu_template(const Tensor& grad_out, const Tensor& log_
 
         log_beta_a[t][s] = std::log(std::exp(lb1-lbmax)+std::exp(lb2-lbmax)+std::exp(lb3-lbmax))+lbmax + log_probs_a[t][current_target_prime];
         // one might check whether one can vectorize this better when done after the t-loop...
-	// now that we have beta, we fill in the sum of alpha*beta in eq (16)
-	// in contrast to the cuda implementation, we only parallelize over the batch, so we don't have a concurrency
-	// issue (several s can map to the same target character)
+        // now that we have beta, we fill in the sum of alpha*beta in eq (16)
+        // in contrast to the cuda implementation, we only parallelize over the batch, so we don't have a concurrency
+        // issue (several s can map to the same target character)
         // collected[b, t, target'[s]] "log+=" log_alpha[t, s]+log_beta[t, s]
         scalar_t log_alpha_beta =  log_alpha_a[t][s] + log_beta_a[t][s];
         scalar_t &lcab = grad_a[t][current_target_prime];
@@ -309,9 +309,9 @@ std::tuple<Tensor, Tensor> ctc_loss_cpu(const Tensor& log_probs, const Tensor& t
   (void)zero_infinity; // only used for backwards
   return AT_DISPATCH_FLOATING_TYPES(log_probs.scalar_type(), "ctc_loss_cpu", [&] {
       if (targets.scalar_type() == kLong) {
-	return ctc_loss_cpu_template<scalar_t, kLong>(log_probs, targets, input_lengths, target_lengths, BLANK);
+        return ctc_loss_cpu_template<scalar_t, kLong>(log_probs, targets, input_lengths, target_lengths, BLANK);
       } else {
-	return ctc_loss_cpu_template<scalar_t, kInt>(log_probs, targets, input_lengths, target_lengths, BLANK);
+        return ctc_loss_cpu_template<scalar_t, kInt>(log_probs, targets, input_lengths, target_lengths, BLANK);
       }
   });
 }
@@ -320,9 +320,9 @@ Tensor ctc_loss_backward_cpu(const Tensor& grad, const Tensor& log_probs, const
                              const Tensor& neg_log_likelihood, const Tensor& log_alpha, int64_t BLANK, bool zero_infinity) {
   return AT_DISPATCH_FLOATING_TYPES(log_probs.scalar_type(), "ctc_loss_backward_cpu", [&] {
       if (targets.scalar_type() == kLong) {
-	return ctc_loss_backward_cpu_template<scalar_t,kLong>(grad, log_probs, targets, input_lengths, target_lengths, neg_log_likelihood, log_alpha, BLANK, zero_infinity);
+        return ctc_loss_backward_cpu_template<scalar_t,kLong>(grad, log_probs, targets, input_lengths, target_lengths, neg_log_likelihood, log_alpha, BLANK, zero_infinity);
       } else {
-	return ctc_loss_backward_cpu_template<scalar_t,kInt>(grad, log_probs, targets, input_lengths, target_lengths, neg_log_likelihood, log_alpha, BLANK, zero_infinity);
+        return ctc_loss_backward_cpu_template<scalar_t,kInt>(grad, log_probs, targets, input_lengths, target_lengths, neg_log_likelihood, log_alpha, BLANK, zero_infinity);
       }
   });
 }

aten/src/ATen/native/NNPACK.cpp

@@ -76,11 +76,11 @@ pthreadpool_t nnpack_threadpool() {
     enum nnp_status nnpack_status = nnp_initialize();
     if (nnpack_status != nnp_status_success) {
       if (nnpack_status == nnp_status_out_of_memory) {
-	throw std::runtime_error("could not initialize NNPack (out of memory)");
+        throw std::runtime_error("could not initialize NNPack (out of memory)");
       } else if (nnpack_status == nnp_status_unsupported_hardware) {
-	throw std::runtime_error("could not initialize NNPack (unsupported hardware)");
+        throw std::runtime_error("could not initialize NNPack (unsupported hardware)");
       } else {
-	throw std::runtime_error("could not initialize NNPack (unknown error)");
+        throw std::runtime_error("could not initialize NNPack (unknown error)");
       }
     }
     unsigned int threads;

aten/src/ATen/native/RNN.cpp

@@ -614,7 +614,7 @@ std::tuple<Tensor, Tensor> NAME(                                               \
             num_layers, dropout_p, train, bidirectional, batch_first);         \
     return std::make_tuple(output, hy);                                        \
   }                                                                            \
-  check_device(_input, _params, hx);					\
+  check_device(_input, _params, hx);                                        \
   auto input = batch_first ? _input.transpose(0, 1) : _input;                  \
   auto params = gather_params(_params, has_biases);                            \
   auto results = _rnn_impl_with_concat<CELL, FullLayer, FullBidirectionalLayer>( \

aten/src/ATen/native/RangeFactories.cpp

@@ -126,10 +126,10 @@ Tensor& arange_cpu_out(Tensor& result, Scalar start, Scalar end, Scalar step) {
     double size_d;
     if (std::is_same<scalar_t, int64_t>::value) {
       size_d = std::ceil(static_cast<double>(end.to<accscalar_t>() - start.to<accscalar_t>())
-			 / step.to<accscalar_t>());
+                         / step.to<accscalar_t>());
     } else {
       size_d = std::ceil(static_cast<double>(end.to<double>() - start.to<double>())
-			 / step.to<double>());
+                         / step.to<double>());
     }
 
     AT_CHECK(xstep > 0 || xstep < 0, "step must be nonzero");

aten/src/ATen/native/cpu/avx_mathfun.h

@@ -100,7 +100,7 @@ typedef union imm_xmm_union {
 
 #define COPY_IMM_TO_XMM(imm_, xmm0_, xmm1_) {    \
     imm_xmm_union u __attribute__((aligned(32)));  \
-    u.imm = imm_;				   \
+    u.imm = imm_;                                   \
     xmm0_ = u.xmm[0];                            \
     xmm1_ = u.xmm[1];                            \
 }
@@ -228,8 +228,8 @@ inline v8sf log256_ps(v8sf x) {
   return x;
 }
 
-_PS256_CONST(exp_hi,	88.3762626647949f);
-_PS256_CONST(exp_lo,	-88.3762626647949f);
+_PS256_CONST(exp_hi,        88.3762626647949f);
+_PS256_CONST(exp_lo,        -88.3762626647949f);
 
 _PS256_CONST(cephes_LOG2EF, 1.44269504088896341);
 _PS256_CONST(cephes_exp_C1, 0.693359375);

aten/src/ATen/native/cuda/CuFFTPlanCache.h

@@ -266,7 +266,7 @@ class CuFFTConfig {
       CUFFT_CHECK(hipfftMakePlanMany(plan(), signal_ndim, signal_sizes.data(),
         /* inembed */ nullptr, /* base_istride */ 1, /* idist */ 1,
         /* onembed */ nullptr, /* base_ostride */ 1, /* odist */ 1,
-	exec_type, batch, &ws_size_t));
+        exec_type, batch, &ws_size_t));
 #else
       CUFFT_CHECK(cufftXtMakePlanMany(plan(), signal_ndim, signal_sizes.data(),
         /* inembed */ nullptr, /* base_istride */ 1, /* idist */ 1, itype,

aten/src/ATen/native/cuda/Embedding.cu

@@ -87,10 +87,10 @@ __global__ void embedding_backward_feature_kernel
           match_found_this_thread = 0;
 #ifdef __HIP_PLATFORM_HCC__
         unsigned long long int matchmask = WARP_BALLOT(match_found_this_thread);
-	int first_remaining_peer = __ffsll(matchmask) - 1;
+        int first_remaining_peer = __ffsll(matchmask) - 1;
 #else
         unsigned int matchmask = WARP_BALLOT(match_found_this_thread);
-	int first_remaining_peer = __ffs(matchmask) - 1;
+        int first_remaining_peer = __ffs(matchmask) - 1;
 #endif
 
         if(threadIdx.y == first_remaining_peer) // Nominate lowest-indexed warp as the leader
@@ -103,7 +103,7 @@ __global__ void embedding_backward_feature_kernel
 #else
             first_remaining_peer = __ffs(matchmask) - 1;
 #endif
-	    my_s[threadIdx.x] += smem[threadIdx.x + WARP_SIZE*first_remaining_peer];
+            my_s[threadIdx.x] += smem[threadIdx.x + WARP_SIZE*first_remaining_peer];
             matchmask ^= (1 << first_remaining_peer);
           }
           if(f < s)