Address memory leak in overloaded operators (#297)

* Make operator overload C bindings subroutines; create empty tensors inside
* Set up destructor for torch_tensor
* No need to call torch_tensor_delete in unit tests
* Test manual/auto delete with fixture extension

Author: jwallwork23

src/ctorch.cpp

@@ -334,83 +334,67 @@ void torch_tensor_delete(torch_tensor_t tensor) {
 // --- Operator overloads acting on tensors
 // =====================================================================================
 
-torch_tensor_t torch_tensor_assign(const torch_tensor_t input) {
+void torch_tensor_assign(torch_tensor_t output, const torch_tensor_t input) {
+  auto out = reinterpret_cast<torch::Tensor *>(output);
   auto in = reinterpret_cast<torch::Tensor *const>(input);
   torch::AutoGradMode enable_grad(in->requires_grad());
-  torch::Tensor *output = nullptr;
-  output = new torch::Tensor;
-  *output = in->detach().clone();
-  return output;
+  *out = *in;
 }
 
-torch_tensor_t torch_tensor_add(const torch_tensor_t tensor1,
-                                const torch_tensor_t tensor2) {
+void torch_tensor_add(torch_tensor_t output, const torch_tensor_t tensor1,
+                      const torch_tensor_t tensor2) {
+  auto out = reinterpret_cast<torch::Tensor *>(output);
   auto t1 = reinterpret_cast<torch::Tensor *const>(tensor1);
   auto t2 = reinterpret_cast<torch::Tensor *const>(tensor2);
-  torch::Tensor *output = nullptr;
-  output = new torch::Tensor;
-  *output = *t1 + *t2;
-  return output;
+  *out = *t1 + *t2;
 }
 
-torch_tensor_t torch_tensor_negative(const torch_tensor_t tensor) {
+void torch_tensor_negative(torch_tensor_t output, const torch_tensor_t tensor) {
+  auto out = reinterpret_cast<torch::Tensor *>(output);
   auto t = reinterpret_cast<torch::Tensor *const>(tensor);
-  torch::Tensor *output = nullptr;
-  output = new torch::Tensor;
-  *output = -*t;
-  return output;
+  *out = -*t;
 }
 
-torch_tensor_t torch_tensor_subtract(const torch_tensor_t tensor1,
-                                     const torch_tensor_t tensor2) {
+void torch_tensor_subtract(torch_tensor_t output, const torch_tensor_t tensor1,
+                           const torch_tensor_t tensor2) {
+  auto out = reinterpret_cast<torch::Tensor *>(output);
   auto t1 = reinterpret_cast<torch::Tensor *const>(tensor1);
   auto t2 = reinterpret_cast<torch::Tensor *const>(tensor2);
-  torch::Tensor *output = nullptr;
-  output = new torch::Tensor;
-  *output = *t1 - *t2;
-  return output;
+  *out = *t1 - *t2;
 }
 
-torch_tensor_t torch_tensor_multiply(const torch_tensor_t tensor1,
-                                     const torch_tensor_t tensor2) {
+void torch_tensor_multiply(torch_tensor_t output, const torch_tensor_t tensor1,
+                           const torch_tensor_t tensor2) {
+  auto out = reinterpret_cast<torch::Tensor *>(output);
   auto t1 = reinterpret_cast<torch::Tensor *const>(tensor1);
   auto t2 = reinterpret_cast<torch::Tensor *const>(tensor2);
-  torch::Tensor *output = nullptr;
-  output = new torch::Tensor;
-  *output = *t1 * *t2;
-  return output;
+  *out = *t1 * *t2;
 }
 
-torch_tensor_t torch_tensor_divide(const torch_tensor_t tensor1,
-                                   const torch_tensor_t tensor2) {
+void torch_tensor_divide(torch_tensor_t output, const torch_tensor_t tensor1,
+                         const torch_tensor_t tensor2) {
+  auto out = reinterpret_cast<torch::Tensor *>(output);
   auto t1 = reinterpret_cast<torch::Tensor *const>(tensor1);
   auto t2 = reinterpret_cast<torch::Tensor *const>(tensor2);
-  torch::Tensor *output = nullptr;
-  output = new torch::Tensor;
-  *output = *t1 / *t2;
-  return output;
+  *out = *t1 / *t2;
 }
 
-torch_tensor_t torch_tensor_power_int(const torch_tensor_t tensor,
-                                      const torch_int_t exponent) {
-  auto t = reinterpret_cast<torch::Tensor *const>(tensor);
+void torch_tensor_power_int(torch_tensor_t output, const torch_tensor_t tensor,
+                            const torch_int_t exponent) {
   // NOTE: The following cast will only work for integer exponents
+  auto out = reinterpret_cast<torch::Tensor *>(output);
+  auto t = reinterpret_cast<torch::Tensor *const>(tensor);
   auto exp = reinterpret_cast<int *const>(exponent);
-  torch::Tensor *output = nullptr;
-  output = new torch::Tensor;
-  *output = pow(*t, *exp);
-  return output;
+  *out = pow(*t, *exp);
 }
 
-torch_tensor_t torch_tensor_power_float(const torch_tensor_t tensor,
-                                        const torch_float_t exponent) {
-  auto t = reinterpret_cast<torch::Tensor *const>(tensor);
+void torch_tensor_power_float(torch_tensor_t output, const torch_tensor_t tensor,
+                              const torch_float_t exponent) {
   // NOTE: The following cast will only work for floating point exponents
+  auto out = reinterpret_cast<torch::Tensor *>(output);
+  auto t = reinterpret_cast<torch::Tensor *const>(tensor);
   auto exp = reinterpret_cast<float *const>(exponent);
-  torch::Tensor *output = nullptr;
-  output = new torch::Tensor;
-  *output = pow(*t, *exp);
-  return output;
+  *out = pow(*t, *exp);
 }
 
 // =============================================================================

src/ctorch.h

@@ -181,72 +181,73 @@ EXPORT_C void torch_tensor_delete(torch_tensor_t tensor);
 
 /**
  * Overloads the assignment operator for Torch Tensor
+ * @param output Tensor
  * @param input Tensor
- * @return copy of input Tensor
  */
-EXPORT_C torch_tensor_t torch_tensor_assign(const torch_tensor_t input);
+EXPORT_C void torch_tensor_assign(torch_tensor_t output, const torch_tensor_t input);
 
 /**
  * Overloads the addition operator for two Torch Tensors
+ * @param sum of the Tensors
  * @param first Tensor to be added
  * @param second Tensor to be added
- * @return sum of the Tensors
  */
-EXPORT_C torch_tensor_t torch_tensor_add(const torch_tensor_t tensor1,
-                                         const torch_tensor_t tensor2);
+EXPORT_C void torch_tensor_add(torch_tensor_t, const torch_tensor_t tensor1,
+                               const torch_tensor_t tensor2);
 
 /**
  * Overloads the minus operator for a single Torch Tensor
+ * @param the negative Tensor
  * @param Tensor to take the negative of
- * @return the negative Tensor
  */
-EXPORT_C torch_tensor_t torch_tensor_negative(const torch_tensor_t tensor);
+EXPORT_C void torch_tensor_negative(torch_tensor_t output, const torch_tensor_t tensor);
 
 /**
  * Overloads the subtraction operator for two Torch Tensors
+ * @param output Tensor
  * @param first Tensor to be subtracted
  * @param second Tensor to be subtracted
- * @return difference of the Tensors
  */
-EXPORT_C torch_tensor_t torch_tensor_subtract(const torch_tensor_t tensor1,
-                                              const torch_tensor_t tensor2);
+EXPORT_C void torch_tensor_subtract(torch_tensor_t output, const torch_tensor_t tensor1,
+                                    const torch_tensor_t tensor2);
 
 /**
  * Overloads the multiplication operator for two Torch Tensors
+ * @param output Tensor
  * @param first Tensor to be multiplied
  * @param second Tensor to be multiplied
- * @return product of the Tensors
  */
-EXPORT_C torch_tensor_t torch_tensor_multiply(const torch_tensor_t tensor1,
-                                              const torch_tensor_t tensor2);
+EXPORT_C void torch_tensor_multiply(torch_tensor_t output, const torch_tensor_t tensor1,
+                                    const torch_tensor_t tensor2);
 
 /**
  * Overloads the division operator for two Torch Tensors.
+ * @param output Tensor
  * @param first Tensor to be divided
  * @param second Tensor to be divided
- * @return quotient of the Tensors
  */
-EXPORT_C torch_tensor_t torch_tensor_divide(const torch_tensor_t tensor1,
-                                            const torch_tensor_t tensor2);
+EXPORT_C void torch_tensor_divide(torch_tensor_t output, const torch_tensor_t tensor1,
+                                  const torch_tensor_t tensor2);
 
 /**
  * Overloads the exponentiation operator for a Torch Tensor and an integer exponent
+ * @param output Tensor
  * @param Tensor to take the power of
  * @param integer exponent
- * @return power of the Tensor
  */
-EXPORT_C torch_tensor_t torch_tensor_power_int(const torch_tensor_t tensor,
-                                               const torch_int_t exponent);
+EXPORT_C void torch_tensor_power_int(torch_tensor_t output, const torch_tensor_t tensor,
+                                     const torch_int_t exponent);
 
 /**
  * Overloads the exponentiation operator for a Torch Tensor and a floating point
  * exponent
+ * @param output Tensor
  * @param Tensor to take the power of
  * @param floating point exponent
- * @return power of the Tensor
  */
-EXPORT_C torch_tensor_t torch_tensor_power_float(const torch_tensor_t tensor,
-                                                 const torch_float_t exponent);
+EXPORT_C void torch_tensor_power_float(torch_tensor_t output,
+                                       const torch_tensor_t tensor,
+                                       const torch_float_t exponent);
 
 // =============================================================================
 // --- Torch model API