Rename sparse tensor contiguous() to coalesce()

Author: adamlerer

test/common.py

@@ -150,8 +150,8 @@ def assertTensorsEqual(a, b):
  self.assertLessEqual(max_err, prec, message)
  self.assertEqual(x.is_sparse, y.is_sparse, message)
  if x.is_sparse:
- x = x.clone().contiguous()
- y = y.clone().contiguous()
+ x = x.clone().coalesce_()
+ y = y.clone().coalesce_()
  assertTensorsEqual(x.indices(), y.indices())
  assertTensorsEqual(x.values(), y.values())
  else:

test/test_sparse.py

@@ -156,7 +156,7 @@ def _test_contig(self, is_cuda):
  [31, 92, 65, 50, 34, 62, 22, 56, 74, 89],
  ])
  exp_v = ValueTensor([2, 1, 6, 4, 10, 3, 5, 9, 8, 7])
- x.contiguous()
+ x.coalesce_()
  self.assertEqual(exp_i, x.indices())
  self.assertEqual(exp_v, x.values())
 
@@ -174,7 +174,7 @@ def _test_contig(self, is_cuda):
  ])
  exp_v = ValueTensor([2, 1, 3, 4])
 
- x.contiguous()
+ x.coalesce_()
  self.assertEqual(exp_i, x.indices())
  self.assertEqual(exp_v, x.values())
 
@@ -193,7 +193,7 @@ def _test_contig(self, is_cuda):
  ])
  exp_v = ValueTensor([6, 4])
 
- x.contiguous()
+ x.coalesce_()
  self.assertEqual(exp_i, x.indices())
  self.assertEqual(exp_v, x.values())
 
@@ -224,7 +224,7 @@ def _test_contig_hybrid(self, is_cuda):
  [2, 3], [1, 2], [6, 7], [4, 5], [10, 11],
  [3, 4], [5, 6], [9, 10], [8, 9], [7, 8],
  ])
- x.contiguous()
+ x.coalesce_()
  self.assertEqual(exp_i, x.indices())
  self.assertEqual(exp_v, x.values())
 
@@ -242,7 +242,7 @@ def _test_contig_hybrid(self, is_cuda):
  ])
  exp_v = ValueTensor([[2, 2, 2], [1, 1, 1], [3, 3, 3], [4, 4, 4]])
 
- x.contiguous()
+ x.coalesce_()
  self.assertEqual(exp_i, x.indices())
  self.assertEqual(exp_v, x.values())
 
@@ -261,7 +261,7 @@ def _test_contig_hybrid(self, is_cuda):
  ])
  exp_v = ValueTensor([[6, 4, 5], [4, 3, 4]])
 
- x.contiguous()
+ x.coalesce_()
  self.assertEqual(exp_i, x.indices())
  self.assertEqual(exp_v, x.values())
 

torch/csrc/generic/methods/SparseTensor.cwrap

@@ -62,9 +62,9 @@ PyObject * THSPTensor_(size)(PyObject *self, PyObject *args, PyObject *kwargs)
 ]]
 
 [[
- name: isContiguous
+ name: isCoalesced
  sparse: yes
- python_name: is_contiguous
+ python_name: is_coalesced
  return: bool
  arguments:
  - THSTensor* self
@@ -89,7 +89,8 @@ PyObject * THSPTensor_(size)(PyObject *self, PyObject *args, PyObject *kwargs)
 ]]
 
 [[
- name: contiguous
+ name: coalesce
+ python_name: coalesce_
  sparse: yes
  return: argument 0
  arguments:

torch/lib/THCS/generic/THCSTensor.c

@@ -71,7 +71,7 @@ static void THCSTensor_(rawInit)(THCState *state, THCSTensor *self)
  self->values = THCTensor_(new)(state);
  self->nDimensionI = 0;
  self->nDimensionV = 0;
- self->contiguous = 0;
+ self->coalesced = 0;
  self->nnz = 0;
  // self->flag = TH_TENSOR_REFCOUNTED;
  self->refcount = 1;
@@ -86,7 +86,7 @@ void THCSTensor_(rawResize)(THCState *state, THCSTensor *self, int nDimI, int nD
  }
  self->nDimensionI = nDimI;
  self->nDimensionV = nDimV;
- self->contiguous = 0;
+ self->coalesced = 0;
 }
 
 // directly assign without cloning or retaining (internal method)
@@ -110,7 +110,7 @@ THCSTensor* THCSTensor_(_move)(THCState *state, THCSTensor *self, THCIndexTensor
  self->indices = indices;
  self->values = values;
  self->nnz = empty ? 0 : THCTensor_(size)(state, values, 0);
- self->contiguous = 0;
+ self->coalesced = 0;
 
  return self;
 }
@@ -236,13 +236,7 @@ THCSTensor *THCSTensor_(newClone)(THCState *state, THCSTensor *self) {
  THCSTensor_(_set)(state, other, self->indices, self->values);
 
  other->nnz = self->nnz;
- other->contiguous = self->contiguous;
- return other;
-}
-
-THCSTensor *THCSTensor_(newContiguous)(THCState *state, THCSTensor *self) {
- THCSTensor *other = THCSTensor_(newClone)(state, self);
- THCSTensor_(contiguous)(state, other);
+ other->coalesced = self->coalesced;
  return other;
 }
 
@@ -340,11 +334,11 @@ void THCSTensor_(copy)(THCState *state, THCSTensor *self, THCSTensor *src) {
  THCSTensor_(rawResize)(state, self, src->nDimensionI, src->nDimensionV, src->size);
  THCSTensor_(_set)(state, self, src->indices, src->values);
  self->nnz = src->nnz;
- self->contiguous = src->contiguous;
+ self->coalesced = src->coalesced;
 }
 
-int THCSTensor_(isContiguous)(THCState *state, const THCSTensor *self) {
- return self->contiguous;
+int THCSTensor_(isCoalesced)(THCState *state, const THCSTensor *self) {
+ return self->coalesced;
 }
 
 void THCSTensor_(free)(THCState *state, THCSTensor *self)
@@ -365,12 +359,6 @@ void THCSTensor_(retain)(THCState *state, THCSTensor *self)
  THAtomicIncrementRef(&self->refcount);
 }
 
-void THCSTensor_(contiguous)(THCState *state, THCSTensor *self) {
- if (self->contiguous) return;
- THCSTensor_(reorder)(state, self);
- self->contiguous = 1;
-}
-
 int THCSTensor_(checkGPU)(THCState *state, unsigned int nSparseTensors, unsigned int nTensors, ...)
 {
  /* FIXME: remove this flag after any users stop using it since it is
@@ -446,7 +434,7 @@ void THCTensor_(sparseMask)(THCState *state, THCSTensor *r_, THCTensor *t, THCST
  THCTensor *rValues = THCTensor_(new)(state);
  THCTensor_(resizeAs)(state, rValues, maskValues);
  THCSTensor_(_move)(state, r_, THCIndexTensor_(newClone)(state, maskIndices), rValues);
- r_->contiguous = mask->contiguous;
+ r_->coalesced = mask->coalesced;
  r_->nnz = mask->nnz;
 
  THCudaLongTensor *indices = THCudaLongTensor_newWithSize1d(state, mask->nnz);

torch/lib/THCS/generic/THCSTensor.cu

@@ -23,7 +23,7 @@ THCTensor *THCSTensor_(toDense)(THCState *state, THCSTensor *self) {
  THLongStorage *size;
  THCTensor *dst;
 
- THCSTensor_(contiguous)(state, self);
+ THCSTensor_(coalesce)(state, self);
 
  // set up the new tensor
  size = THCSTensor_(newSizeOf)(state, self);
@@ -61,7 +61,8 @@ THCTensor *THCSTensor_(toDense)(THCState *state, THCSTensor *self) {
  return dst;
 }
 
-void THCSTensor_(reorder)(THCState *state, THCSTensor *self) {
+void THCSTensor_(coalesce)(THCState *state, THCSTensor *self) {
+ if (self->coalesced) return;
  if (self->nnz < 2) return;
 #if CUDA_VERSION >= 7000
  THCThrustAllocator thrustAlloc(state);
@@ -80,7 +81,7 @@ void THCSTensor_(reorder)(THCState *state, THCSTensor *self) {
  // Multiple values in D1 can map to the same position in D2 if there are duplicate indices
  // Values mapping to the same position are added together (which is what matrix multiplication does)
  //
- // When constructing S, we must make sure that it is contiguous (otherwise this function will call itself when doing the multiplication)
+ // When constructing S, we must make sure that it is coalesced (otherwise this function will call itself when doing the multiplication)
  // To achieve this, we define the indices tensor of S as follows:
  // * the second row contains the permutation corresponding to a stable sort of the original indices
  // * the first row "maps" those indices to their final location after deduplication
@@ -142,7 +143,7 @@ void THCSTensor_(reorder)(THCState *state, THCSTensor *self) {
  // build S
  THCSTensor *S = THCSTensor_(newWithSize2d)(state, newNnz, self->nnz);
  THCSTensor_(_move)(state, S, sIndices, sValues);
- S->contiguous = 1;
+ S->coalesced = 1;
 
  // build output indices tensor by doing an indexSelect over the sorted list of unique indices
  THCIndexTensor *newIndices = THCIndexTensor_(new)(state);
@@ -201,6 +202,8 @@ void THCSTensor_(reorder)(THCState *state, THCSTensor *self) {
  THCTensor_(free)(state, newValuesView);
  }
 
+self->coalesced = 1;
+
 #undef THRUST_EXEC
 }
 
@@ -220,7 +223,7 @@ void THCSTensor_(transpose)(THCState *state, THCSTensor *self, int d1, int d2) {
  long i = self->size[d1];
  self->size[d1] = self->size[d2];
  self->size[d2] = i;
- self->contiguous = 0;
+ self->coalesced = 0;
  THCIndexTensor_(free)(state, indices);
  THCIndexTensor_(free)(state, buffer);
  THCIndexTensor_(free)(state, slice1);

torch/lib/THCS/generic/THCSTensor.h

@@ -14,7 +14,7 @@ typedef struct THCSTensor
  THCIndexTensor *indices;
  THCTensor *values;
  // Math operations can only be performed on ordered sparse tensors
- int contiguous;
+ int coalesced;
  int refcount;
 
 } THCSTensor;
@@ -41,7 +41,6 @@ TH_API THCSTensor *THCSTensor_(newWithSize3d)(THCState *state, long size0_, long
 TH_API THCSTensor *THCSTensor_(newWithSize4d)(THCState *state, long size0_, long size1_, long size2_, long size3_);
 
 TH_API THCSTensor *THCSTensor_(newClone)(THCState *state, THCSTensor *self);
-TH_API THCSTensor *THCSTensor_(newContiguous)(THCState *state, THCSTensor *self);
 TH_API THCSTensor *THCSTensor_(newTranspose)(THCState *state, THCSTensor *self, int dimension1_, int dimension2_);
 
 /**** reshaping methods ***/
@@ -58,8 +57,8 @@ TH_API THCTensor *THCSTensor_(toDense)(THCState *state, THCSTensor *self);
 TH_API void THCSTensor_(copy)(THCState *state, THCSTensor *self, THCSTensor *src);
 
 TH_API void THCSTensor_(transpose)(THCState *state, THCSTensor *self, int dimension1_, int dimension2_);
-TH_API int THCSTensor_(isContiguous)(THCState *state, const THCSTensor *self);
-TH_API void THCSTensor_(contiguous)(THCState *state, THCSTensor *self);
+TH_API int THCSTensor_(isCoalesced)(THCState *state, const THCSTensor *self);
+TH_API void THCSTensor_(coalesce)(THCState *state, THCSTensor *self);
 
 TH_API void THCTensor_(sparseMask)(THCState *state, THCSTensor *r_, THCTensor *t, THCSTensor *mask);
 
@@ -72,7 +71,6 @@ TH_API int THCSTensor_(checkGPU)(THCState *state, unsigned int nSparseTensors, u
 
 /* internal methods */
 TH_API void THCSTensor_(rawResize)(THCState *state, THCSTensor *self, int nDimI, int nDimV, long *size);
-TH_API void THCSTensor_(reorder)(THCState *state, THCSTensor *self);
 TH_API THCTensor *THCSTensor_(newValuesWithSizeOf)(THCState *state, THCTensor *values, long nnz);
 TH_API THCSTensor* THCSTensor_(_move)(THCState *state, THCSTensor *self, THCIndexTensor *indices, THCTensor *values);
 TH_API THCSTensor* THCSTensor_(_set)(THCState *state, THCSTensor *self, THCIndexTensor *indices, THCTensor *values);

torch/lib/THCS/generic/THCSTensorMath.cu

@@ -67,7 +67,7 @@ void THCSTensor_(spaddmm)(THCState *state, THCTensor *r_, real beta, THCTensor *
  THArgCheck(THCTensor_(size)(state, dense, 0) == k, 3,
  "Expected dim 0 size %d, got %d", k, THCTensor_(size)(state, dense, 0));
 
- THCSTensor_(contiguous)(state, sparse);
+ THCSTensor_(coalesce)(state, sparse);
 
  long nnz = THCSTensor_(nnz)(state, sparse);
  indices = THCSTensor_(newIndices)(state, sparse);
@@ -182,7 +182,7 @@ void THCSTensor_(hspmm)(THCState *state, THCSTensor *r_, real alpha, THCSTensor
  long size[2] = {m, n};
  THCSTensor_(rawResize)(state, r_, 1, 1, size);
 
- THCSTensor_(contiguous)(state, sparse);
+ THCSTensor_(coalesce)(state, sparse);
 
  long nnz = THCSTensor_(nnz)(state, sparse);
  THCIndexTensor *indices = THCIndexTensor_(newWithSize2d)(state, 1, nnz);
@@ -213,7 +213,7 @@ void THCSTensor_(hspmm)(THCState *state, THCSTensor *r_, real alpha, THCSTensor
 void THCSTensor_(spcadd)(THCState *state, THCTensor *r_, THCTensor *dense, real value, THCSTensor *sparse) {
  THCAssertSameGPU(THCSTensor_(checkGPU)(state, 1, 3, sparse, r_, dense));
  THCTensor_(resizeAs)(state, r_, dense);
- THCSTensor_(contiguous)(state, sparse);
+ THCSTensor_(coalesce)(state, sparse);
 
  THCIndexTensor *indices = THCSTensor_(newIndices)(state, sparse);
  THCTensor *values = THCSTensor_(newValues)(state, sparse);
@@ -274,7 +274,7 @@ void THCSTensor_(mul)(THCState *state, THCSTensor *r_, THCSTensor *t, real value
  THCIndexTensor_(copy)(state, r_indices_, t_indices_);
  THCTensor_(mul)(state, r_values_, t_values_, value);
  r_->nnz = t->nnz;
- r_->contiguous = t->contiguous;
+ r_->coalesced = t->coalesced;
 
  THCIndexTensor_(free)(state, r_indices_);
  THCTensor_(free)(state, r_values_);
@@ -300,7 +300,7 @@ void THCSTensor_(div)(THCState *state, THCSTensor *r_, THCSTensor *t, real value
  THCIndexTensor_(copy)(state, r_indices_, t_indices_);
  THCTensor_(div)(state, r_values_, t_values_, value);
  r_->nnz = t->nnz;
- r_->contiguous = t->contiguous;
+ r_->coalesced = t->coalesced;
 
  THCIndexTensor_(free)(state, r_indices_);
  THCTensor_(free)(state, r_values_);
@@ -314,8 +314,8 @@ void THCSTensor_(cadd)(THCState *state, THCSTensor *r_, THCSTensor *t, real valu
  if(!THCSTensor_(isSameSizeAs)(state, t, src)) {
  THError("cadd operands have incompatible sizes or dimension types");
  }
- THCSTensor_(contiguous)(state, t);
- THCSTensor_(contiguous)(state, src);
+ THCSTensor_(coalesce)(state, t);
+ THCSTensor_(coalesce)(state, src);
 
  if (src->nnz == 0) {
  THCSTensor_(copy)(state, r_, t);
@@ -328,7 +328,7 @@ void THCSTensor_(cadd)(THCState *state, THCSTensor *r_, THCSTensor *t, real valu
 
  // We deliberately choose to simply concat the indices and values tensors
  // rather than merging them. This removes the need to synchronously fetch nnz
- // at the end of the operation, at the cost of having a non-contiguous result.
+ // at the end of the operation, at the cost of having a non-coalesced result.
  // This trade-off is preferable for the common use-case of gradient accumulation.
  // TODO have two distinct functions? The other option is commented out below
  THCIndexTensor *t_indices_ = THCSTensor_(newIndices)(state, t);
@@ -392,7 +392,7 @@ void THCSTensor_(cadd)(THCState *state, THCSTensor *r_, THCSTensor *t, real valu
  // unsigned long nnzOut;
  // THCudaCheck(cudaMemcpy(&nnzOut, scratchSpace, sizeof(unsigned long), cudaMemcpyDeviceToHost));
  // r_->nnz = nnzOut;
- // r_->contiguous = 1;
+ // r_->coalesced = 1;
  // if (freeScratchSpace) {
  // THCudaCheck(THCudaFree(state, scratchSpace));
  // }
@@ -412,8 +412,8 @@ void THCSTensor_(cmul)(THCState *state, THCSTensor *r_, THCSTensor *t, THCSTenso
  if(!THCSTensor_(isSameSizeAs)(state, t, src)) {
  THError("cmul operands have incompatible sizes or dimension types");
  }
- THCSTensor_(contiguous)(state, t);
- THCSTensor_(contiguous)(state, src);
+ THCSTensor_(coalesce)(state, t);
+ THCSTensor_(coalesce)(state, src);
 
  if (t->nnz == 0 || src->nnz == 0) {
  THCSTensor_(zero)(state, r_);
@@ -455,7 +455,7 @@ void THCSTensor_(cmul)(THCState *state, THCSTensor *r_, THCSTensor *t, THCSTenso
  THCudaCheck(cudaGetLastError());
  r_->nnz = THCudaLongStorage_get(state, resultNnz, 0);
  THCudaLongStorage_free(state, resultNnz);
- r_->contiguous = 1;
+ r_->coalesced = 1;
 
  THCIndexTensor_(free)(state, t_indices_);
  THCTensor_(free)(state, t_values_);

torch/lib/THPP/tensors/generic/THCSTensor.cpp

@@ -41,7 +41,7 @@ auto THCSTensor<real>::clone_shallow() -> THCSTensor* {
 
 template<>
 auto THCSTensor<real>::contiguous() const -> std::unique_ptr<Tensor> {
- return std::unique_ptr<Tensor>(new THCSTensor(state, THCSTensor_(newContiguous)(state, tensor)));
+ throw std::runtime_error("THCSTensor::contiguous() not supported");
 }
 
 template<>

torch/lib/THPP/tensors/generic/THSTensor.cpp

@@ -40,7 +40,7 @@ auto THSTensor<real>::clone_shallow() -> THSTensor* {
 
 template<>
 auto THSTensor<real>::contiguous() const -> std::unique_ptr<Tensor> {
- return std::unique_ptr<Tensor>(new THSTensor(THSTensor_(newContiguous)(tensor)));
+ throw std::runtime_error("THCSTensor::rawStrides() not supported");
 }
 
 template<>