Add more newContiguous calls and checks

Author: apaszke

generic/PReLU.c

@@ -82,6 +82,7 @@ void THNN_(PReLU_updateGradInput)(
  {
  input = THTensor_(newContiguous)(input);
  gradOutput = THTensor_(newContiguous)(gradOutput);
+ weight = THTensor_(newContiguous)(weight);
  const real *input_data = THTensor_(data)(input);
  const real *gradOutput_data = THTensor_(data)(gradOutput);
  const real *weight_data = THTensor_(data)(weight);
@@ -126,6 +127,7 @@ void THNN_(PReLU_updateGradInput)(
  }
  THTensor_(free)(input);
  THTensor_(free)(gradOutput);
+ THTensor_(free)(weight);
  }
 }
 
@@ -143,10 +145,10 @@ void THNN_(PReLU_accGradParameters)(
 {
  real scale = TH_CONVERT_ACCREAL_TO_REAL(scale_);
  THNN_CHECK_NELEMENT(input, gradOutput);
- real *gradWeight_data = THTensor_(data)(gradWeight);
 
  if (nOutputPlane == 0)
  {
+ real *gradWeight_data = THTensor_(data)(gradWeight);
  real sum = 0;
  TH_TENSOR_APPLY2(real, input, real, gradOutput,
  if ((*input_data) <= 0)
@@ -156,8 +158,10 @@ void THNN_(PReLU_accGradParameters)(
  }
  else
  {
+ THArgCheck(THTensor_(isContiguous)(gradWeight), 6, "gradWeight needs to be contiguous");
  input = THTensor_(newContiguous)(input);
  gradOutput = THTensor_(newContiguous)(gradOutput);
+ weight = THTensor_(newContiguous)(weight);
  long bs = 1, ks = 1;
  {
  long input_ndim = THTensor_(nDimension)(input);
@@ -196,6 +200,7 @@ void THNN_(PReLU_accGradParameters)(
  }
  THTensor_(free)(input);
  THTensor_(free)(gradOutput);
+ THTensor_(free)(weight);
  }
 }
 

generic/SparseLinear.c

@@ -62,6 +62,8 @@ void THNN_(SparseLinear_updateOutput)(
  THLongTensor * csr = THLongTensor_newWithSize1d(batchSize+1);
  THLongTensor_zero(csr);
 
+ weight = THTensor_(newContiguous)(weight);
+
 //#pragma omp parallel for private(i, h, hp0, hp1) schedule(static) if (nnz > 10000)
  for (i=0; i<nnz; i++) {
  hp0 = (long)(THNN_(get2d)(input, i, 0)) - 1;
@@ -106,6 +108,7 @@ void THNN_(SparseLinear_updateOutput)(
  }
  THTensor_(free)(output_row);
  THLongTensor_free(csr);
+ THTensor_(free)(weight);
 }
 
 void THNN_(SparseLinear_legacyUpdateOutput)(
@@ -123,6 +126,8 @@ void THNN_(SparseLinear_legacyUpdateOutput)(
  THArgCheck(THTensor_(isContiguous)(output), 3, "output must be contiguous");
  THArgCheck(THNN_(checkSize1D)(bias, outDim), 5, "bias size wrong");
 
+ weight = THTensor_(newContiguous)(weight);
+
  long batchSize = THTensor_(size)(input, 0);
  long nnz = THTensor_(size)(input, 1);
  THTensor_(resize2d)(output, batchSize, outDim);
@@ -157,6 +162,7 @@ void THNN_(SparseLinear_legacyUpdateOutput)(
  THTensor_(cadd)(output_row, bias, 1.0, output_row);
  }
  THTensor_(free)(output_row);
+ THTensor_(free)(weight);
 }
 
 void THNN_(SparseLinear_accGradParameters)(
@@ -189,6 +195,7 @@ void THNN_(SparseLinear_accGradParameters)(
 
  THLongTensor* csc = THLongTensor_newWithSize1d(inDim+1);
  THLongTensor_zero(csc);
+ weight = THTensor_(newContiguous)(weight);
 
 #pragma omp parallel for private(i, h, hp0, hp1) schedule(static) if (nnz > 10000)
  for (i = 0; i < nnz; i++) {
@@ -235,6 +242,7 @@ void THNN_(SparseLinear_accGradParameters)(
  if (weightDecay != 0) {
  THTensor_(cadd)(gradWeight, gradWeight, weightDecay, weight);
  }
+ THTensor_(free)(weight);
 }
 
 void THNN_(SparseLinear_legacyAccGradParameters)(

generic/SpatialConvolutionLocal.c

@@ -3,17 +3,17 @@
 #else
 
 static inline void THNN_(SpatialConvolutionLocal_shapeCheck)(
-THTensor *input, THTensor *gradOutput,
-THTensor *weight, THTensor *bias,
-int kH, int kW, int dH,
-int dW, int padH, int padW,
-long inputHeight, long inputWidth,
-long outputHeight, long outputWidth) {
+ THTensor *input, THTensor *gradOutput,
+ THTensor *weight, THTensor *bias,
+ int kH, int kW, int dH,
+ int dW, int padH, int padW,
+ long inputHeight, long inputWidth,
+ long outputHeight, long outputWidth) {
 
  THArgCheck(kW > 0 && kH > 0, 9,
- "kernel size should be greater than zero, but got kH: %d kW: %d", kH, kW);
+  "kernel size should be greater than zero, but got kH: %d kW: %d", kH, kW);
  THArgCheck(dW > 0 && dH > 0, 11,
- "stride should be greater than zero, but got dH: %d dW: %d", dH, dW);
+  "stride should be greater than zero, but got dH: %d dW: %d", dH, dW);
 
  int ndim = input->nDimension;
  int dimf = 0;
@@ -27,7 +27,7 @@ static inline void THNN_(SpatialConvolutionLocal_shapeCheck)(
  }
 
  THNN_ARGCHECK(ndim == 3 || ndim == 4, 2, input,
-"3D or 4D input tensor expected but got: %s");
+ "3D or 4D input tensor expected but got: %s");
 
  long nInputPlane = weight->size[2] / (kH * kW);
  long nOutputPlane = weight->size[1];
@@ -47,21 +47,22 @@ static inline void THNN_(SpatialConvolutionLocal_shapeCheck)(
  }
 }
 
-static int THNN_(view_weight_local)(THTensor **_weight)
+static THTensor* THNN_(view_weight_local)(THTensor *_weight)
 {
- THTensor *weight = *_weight;
+ THTensor *weight = THTensor_(newContiguous)(_weight);
  THArgCheck(weight->nDimension == 3 || weight->nDimension == 6, 4,
  "weight tensor should be 3D or 6D - got %dD", weight->nDimension);
  if (weight->nDimension == 6) {
  long s1 = weight->size[0] * weight->size[1];
  long s2 = weight->size[2];
  long s3 = weight->size[3] * weight->size[4] * weight->size[5];
- *_weight = THTensor_(newWithStorage3d)(weight->storage,
- weight->storageOffset,
- s1, -1, s2, -1, s3, -1);
- return 1;
+ THTensor *old_weight = weight;
+ weight = THTensor_(newWithStorage3d)(weight->storage,
+ weight->storageOffset,
+ s1, -1, s2, -1, s3, -1);
+ THTensor_(free)(old_weight);
  }
- return 0;
+ return weight;
 }
 
 static void THNN_(SpatialConvolutionLocal_updateOutput_frame)
@@ -76,8 +77,8 @@ static void THNN_(SpatialConvolutionLocal_updateOutput_frame)
  THTensor *output3d, *finput3d;
 
  THNN_(unfolded_copy)(finput, input, kW, kH, dW, dH, padW, padH,
- nInputPlane, inputWidth, inputHeight,
- outputWidth, outputHeight);
+  nInputPlane, inputWidth, inputHeight,
+  outputWidth, outputHeight);
 
  THTensor_(copy)(output, bias);
 
@@ -116,7 +117,7 @@ void THNN_(SpatialConvolutionLocal_updateOutput)(
  long inputWidth, long inputHeight,
  long outputWidth, long outputHeight)
 {
- int freeWeight = THNN_(view_weight_local)(&weight);
+ weight = THNN_(view_weight_local)(weight);
 
  THNN_(SpatialConvolutionLocal_shapeCheck)
  (input, NULL, weight, bias, kH, kW, dH, dW, padH, padW,
@@ -154,10 +155,10 @@ void THNN_(SpatialConvolutionLocal_updateOutput)(
  THTensor *finput_t = THTensor_(newSelect)(finput, 0, t);
 
  THNN_(SpatialConvolutionLocal_updateOutput_frame)
-(input_t, output_t, weight, bias, finput_t,
- kW, kH, dW, dH, padW, padH,
- nInputPlane, inputWidth, inputHeight,
- nOutputPlane, outputWidth, outputHeight);
+ (input_t, output_t, weight, bias, finput_t,
+  kW, kH, dW, dH, padW, padH,
+  nInputPlane, inputWidth, inputHeight,
+  nOutputPlane, outputWidth, outputHeight);
 
  THTensor_(free)(input_t);
  THTensor_(free)(output_t);
@@ -166,8 +167,7 @@ void THNN_(SpatialConvolutionLocal_updateOutput)(
  }
 
  THTensor_(free)(input);
- if (freeWeight)
- THTensor_(free)(weight);
+ THTensor_(free)(weight);
 }
 
 
@@ -198,8 +198,8 @@ static void THNN_(SpatialConvolutionLocal_updateGradInput_frame)
  THTensor_(zero)(gradInput);
 
  THNN_(unfolded_acc)(fgradInput, gradInput, kW, kH, dW, dH, padW, padH,
- nInputPlane, inputWidth, inputHeight,
- outputWidth, outputHeight);
+  nInputPlane, inputWidth, inputHeight,
+  outputWidth, outputHeight);
 
 }
 
@@ -217,7 +217,7 @@ void THNN_(SpatialConvolutionLocal_updateGradInput)(
  long inputWidth, long inputHeight,
  long outputWidth, long outputHeight)
 {
- int freeWeight = THNN_(view_weight_local)(&weight);
+ weight = THNN_(view_weight_local)(weight);
 
  THNN_(SpatialConvolutionLocal_shapeCheck)
  (input, gradOutput, weight, NULL, kH, kW, dH, dW, padH, padW,
@@ -255,10 +255,10 @@ void THNN_(SpatialConvolutionLocal_updateGradInput)(
  THTensor *fgradInput_t = THTensor_(newSelect)(fgradInput, 0, t);
 
  THNN_(SpatialConvolutionLocal_updateGradInput_frame)
-(gradInput_t, gradOutput_t, tweight, fgradInput_t,
- kW, kH, dW, dH, padW, padH,
- nInputPlane, inputWidth, inputHeight,
- nOutputPlane, outputWidth, outputHeight);
+ (gradInput_t, gradOutput_t, tweight, fgradInput_t,
+  kW, kH, dW, dH, padW, padH,
+  nInputPlane, inputWidth, inputHeight,
+  nOutputPlane, outputWidth, outputHeight);
 
  THTensor_(free)(gradInput_t);
  THTensor_(free)(gradOutput_t);
@@ -269,9 +269,7 @@ void THNN_(SpatialConvolutionLocal_updateGradInput)(
  THTensor_(free)(tweight);
  THTensor_(free)(input);
  THTensor_(free)(gradOutput);
- if (freeWeight)
- THTensor_(free)(weight);
-
+ THTensor_(free)(weight);
 }
 
 static void THNN_(SpatialConvolutionLocal_accGradParameters_frame)
@@ -317,8 +315,10 @@ void THNN_(SpatialConvolutionLocal_accGradParameters)(
  long outputWidth, long outputHeight,
  accreal scale_)
 {
+ THArgCheck(THTensor_(isContiguous)(gradWeight), 4, "gradWeight needs to be contiguous");
+ THArgCheck(THTensor_(isContiguous)(gradBias), 5, "gradBias needs to be contiguous");
  real scale = TH_CONVERT_ACCREAL_TO_REAL(scale_);
- int freeWeight = THNN_(view_weight_local)(&gradWeight);
+ gradWeight = THNN_(view_weight_local)(gradWeight);
 
  THNN_(SpatialConvolutionLocal_shapeCheck)
  (input, gradOutput, gradWeight, gradBias, kH, kW, dH, dW, padH, padW,
@@ -349,10 +349,10 @@ void THNN_(SpatialConvolutionLocal_accGradParameters)(
  THTensor *finput_t = THTensor_(newSelect)(finput, 0, t);
 
  THNN_(SpatialConvolutionLocal_accGradParameters_frame)
-(gradOutput_t, gradWeight, gradBias, finput_t, scale,
- kW, kH, dW, dH, padW, padH,
- nInputPlane, inputWidth, inputHeight,
- nOutputPlane, outputWidth, outputHeight);
+ (gradOutput_t, gradWeight, gradBias, finput_t, scale,
+  kW, kH, dW, dH, padW, padH,
+  nInputPlane, inputWidth, inputHeight,
+  nOutputPlane, outputWidth, outputHeight);
 
  THTensor_(free)(gradOutput_t);
  THTensor_(free)(finput_t);
@@ -361,10 +361,7 @@ void THNN_(SpatialConvolutionLocal_accGradParameters)(
 
  THTensor_(free)(input);
  THTensor_(free)(gradOutput);
-
- if (freeWeight)
- THTensor_(free)(gradWeight);
-
+ THTensor_(free)(gradWeight);
 }
 
 #endif

generic/SpatialConvolutionMM.c

@@ -53,6 +53,19 @@ static inline void THNN_(SpatialConvolutionMM_shapeCheck)(
  }
 }
 
+static THTensor* THNN_(view_weight_MM2d)(THTensor *weight) {
+ weight = THTensor_(newContiguous)(weight);
+ if (weight->nDimension == 4) {
+ long s1 = weight->size[0];
+ long s2 = weight->size[1] * weight->size[2] * weight->size[3];
+ THTensor *old_weight = weight;
+ weight = THTensor_(newWithStorage2d)(weight->storage, weight->storageOffset,
+ s1, -1, s2, -1);
+THTensor_(free)(old_weight);
+ }
+ return weight;
+}
+
 static void THNN_(SpatialConvolutionMM_updateOutput_frame)(
  THTensor *input,
  THTensor *output,
@@ -111,15 +124,7 @@ void THNN_(SpatialConvolutionMM_updateOutput)(
  int padW,
  int padH)
 {
- int freeWeight = 0;
-
- if (weight->nDimension == 4) {
- long s1 = weight->size[0];
- long s2 = weight->size[1] * weight->size[2] * weight->size[3];
- weight = THTensor_(newWithStorage2d)(weight->storage, weight->storageOffset,
- s1, -1, s2, -1);
- freeWeight = 1;
- }
+ weight = THNN_(view_weight_MM2d)(weight);
 
  THNN_(SpatialConvolutionMM_shapeCheck)
  (input, NULL, weight, bias, kH, kW, dH, dW, padH, padW);
@@ -182,8 +187,7 @@ void THNN_(SpatialConvolutionMM_updateOutput)(
  }
 
  THTensor_(free)(input);
- if (freeWeight)
- THTensor_(free)(weight);
+ THTensor_(free)(weight);
 }
 
 static void THNN_(SpatialConvolutionMM_updateGradInput_frame)(
@@ -228,15 +232,7 @@ void THNN_(SpatialConvolutionMM_updateGradInput)(
  int padW,
  int padH)
 {
- int freeWeight = 0;
-
- if (weight->nDimension == 4) {
- long s1 = weight->size[0];
- long s2 = weight->size[1] * weight->size[2] * weight->size[3];
- weight = THTensor_(newWithStorage2d)(weight->storage, weight->storageOffset,
- s1, -1, s2, -1);
- freeWeight = 1;
- }
+ weight = THNN_(view_weight_MM2d)(weight);
 
  THNN_(SpatialConvolutionMM_shapeCheck)
  (input, gradOutput, weight, NULL, kH, kW, dH, dW, padH, padW);
@@ -285,8 +281,7 @@ void THNN_(SpatialConvolutionMM_updateGradInput)(
  THTensor_(free)(tweight);
  THTensor_(free)(input);
  THTensor_(free)(gradOutput);
- if (freeWeight)
- THTensor_(free)(weight);
+ THTensor_(free)(weight);
 }
 
 static void THNN_(SpatialConvolutionMM_accGradParameters_frame)(
@@ -338,17 +333,11 @@ void THNN_(SpatialConvolutionMM_accGradParameters)(
  int padH,
  accreal scale_)
 {
+ THArgCheck(THTensor_(isContiguous)(gradWeight), 4, "gradWeight needs to be contiguous");
+ THArgCheck(THTensor_(isContiguous)(gradBias), 5, "gradBias needs to be contiguous");
+
  real scale = TH_CONVERT_ACCREAL_TO_REAL(scale_);
- int freeWeight = 0;
-
- if (gradWeight->nDimension == 4) {
- long s1 = gradWeight->size[0];
- long s2 = gradWeight->size[1] * gradWeight->size[2] * gradWeight->size[3];
- gradWeight = THTensor_(newWithStorage2d)(gradWeight->storage,
- gradWeight->storageOffset,
- s1, -1, s2, -1);
- freeWeight = 1;
- }
+ gradWeight = THNN_(view_weight_MM2d)(gradWeight);
 
  THNN_(SpatialConvolutionMM_shapeCheck)
  (input, gradOutput, gradWeight, gradBias, kH, kW, dH, dW, padH, padW);
@@ -381,8 +370,7 @@ void THNN_(SpatialConvolutionMM_accGradParameters)(
 
  THTensor_(free)(input);
  THTensor_(free)(gradOutput);
- if (freeWeight)
- THTensor_(free)(gradWeight);
+ THTensor_(free)(gradWeight);
 }
 
 #endif