Removed the memory leaks directly in execution session

src/Runtime/ExecutionSession.cpp

@@ -26,6 +26,8 @@
 
 #include "ExecutionSession.hpp"
 
+void omTensorListDestroyWithoutDestroyingTensors(OMTensorList *list);
+
 namespace onnx_mlir {
 const std::string ExecutionSession::_queryEntryPointsName =
     "omQueryEntryPoints";
@@ -85,6 +87,13 @@ std::vector<OMTensorUniquePtr> ExecutionSession::run(
   auto *wrappedInput = omTensorListCreate(&omts[0], (int64_t)omts.size());
 
   auto *wrappedOutput = _entryPointFunc(wrappedInput);
+
+  // We created a wrapper for the input list, but the input list does not really
+  // own the tensor in the list, as they are coming as OMTensorUniquePtr. So we
+  // need to simply deallocate the list structure without touching the
+  // OMTensors.
+  omTensorListDestroyWithoutDestroyingTensors(wrappedInput);
+
   if (!wrappedOutput)
     throw std::runtime_error(reportErrnoError());
   std::vector<OMTensorUniquePtr> outs;
@@ -93,6 +102,12 @@ std::vector<OMTensorUniquePtr> ExecutionSession::run(
     outs.emplace_back(OMTensorUniquePtr(
         omTensorListGetOmtByIndex(wrappedOutput, i), omTensorDestroy));
   }
+
+  // We created a wrapper for the output list, but the output list does not
+  // really own the tensor in the list, as they are returned in a vector of
+  // OMTensorUniquePtr. So we need to simply deallocate the list structure
+  // without touching the OMTensors.
+  omTensorListDestroyWithoutDestroyingTensors(wrappedOutput);
   errno = 0; // No errors.
   return outs;
 }

src/Runtime/OMTensor.inc

@@ -284,8 +284,9 @@ OMTensor *omTensorCreateEmpty(
 void omTensorDestroy(OMTensor *tensor) {
   if (!tensor)
     return;
-  if (tensor->_owning)
+  if (tensor->_owning) {
     free(tensor->_allocatedPtr);
+  }
   free(tensor->_shape);
   free(tensor->_strides);
   free(tensor);

src/Runtime/OMTensorList.inc

@@ -103,8 +103,23 @@ void omTensorListDestroy(OMTensorList *list) {
     return;
   for (int64_t i = 0; i < list->_size; i++)
     omTensorDestroy(list->_omts[i]);
-  if (list->_owning)
+  if (list->_owning) {
     free(list->_omts);
+  }
+  free(list);
+}
+
+/* OMTensorList destroyer which does not destroy the tensors. Currently an
+ * unpublished call that is mainly used to handle the unique tensor scheme used
+ * in Execution Session.
+ */
+void omTensorListDestroyWithoutDestroyingTensors(OMTensorList *list) {
+  if (!list)
+    return;
+  // Omit destruction of the OMTensors.
+  if (list->_owning) {
+    free(list->_omts);
+  }
   free(list);
 }
 

test/numerical/TestLoop.cpp

@@ -118,9 +118,9 @@ bool isOMLoopTheSameAsNaiveImplFor(std::string moduleIR,
   omTensorGetElem<bool>(condTensor.get(), {}) = true;
   inputs.emplace_back(move(condTensor));
 
-  auto *yInitShape = new int64_t[1]{1};
+  int64_t yInitShape = 1;
   auto yInitTensor = OMTensorUniquePtr(
-      omTensorCreateEmpty(&yInitShape[0], 1, OM_DATA_TYPE::ONNX_TYPE_INT64),
+      omTensorCreateEmpty(&yInitShape, 1, OM_DATA_TYPE::ONNX_TYPE_INT64),
       omTensorDestroy);
   omTensorGetElem<int64_t>(yInitTensor.get(), {0}) = yInit;
   inputs.emplace_back(move(yInitTensor));
@@ -135,9 +135,9 @@ bool isOMLoopTheSameAsNaiveImplFor(std::string moduleIR,
     return false;
   }
 
-  auto *yRefInitShape = new int64_t[1]{1};
+  int64_t yRefInitShape = 1;
   auto vFinalRef = OMTensorUniquePtr(
-      omTensorCreateEmpty(&yRefInitShape[0], 1, OM_DATA_TYPE::ONNX_TYPE_INT64),
+      omTensorCreateEmpty(&yRefInitShape, 1, OM_DATA_TYPE::ONNX_TYPE_INT64),
       omTensorDestroy);
 
   omTensorGetElem<int64_t>(vFinalRef.get(), {0}) = yInit;