SWDEV-534207 - solve phoenix mem test failures (#218)

* make sure symbolStatus after hipGetProcAddress() is the expected in the tests that are failing on Phoenix
* fix that calls to hipMemset2DAsync() and hipMemset2DAsync_spt() to set values on submatrices where not taking into account the pitch, causing test failures on Phoenix
* before testing whether hipMemset2DAsync() works, initialize the whole matrix to a known value. This makes sure the test fails even if the uninitialized memory returned after hipMallocPitch() happens to have the expected value
* Sbefore testing whether hipMemset2DAsync_spt() works, initialize the whole matrix to a known value. This makes sure the test fails even if the uninitialized memory returned after hipMallocPitch() happens to have the expected value
* fix up compiler error: dyn_hipMemset2DAsync_ptr should have been dyn_hipMemset2DAsync_spt_ptr
* when Unit_hipMalloc3D_Basic fails due to a potential memory leak, print the values that hipMemGetInfo() returns before and after the allocation/deallocation pair.
* Also print intermediate free memory
* Make sure Unit_hipMalloc3D_Basic allocates at least PalSettings::subAllocationChunkSize_ on Windows. Otherwise hipMemGetInfo() will not report an increase on available memory after hipFree() is called, as the minimum amount of memory that cause a call to the CoarseMemorySubAllocator::Create() is that chunk size
* Fix up previous commit; allocated too much memory
* skip some extent sizes in Unit_hipFreeMipmappedArrayImplicitSyncArray if allocating them would be require more memory than the actual totalGlobalMem of the device
* Do not expect an exact match when comparing the memory available memory before and after hipMalloc3D() + hipFree()
* Do not allocate more memory than the total GPU memory in Unit_hipFreeMipmappedArrayImplicitSyncArray
* fix expected available memory amount comparison in hipMalloc3D - Basic
* use SUCCEED() macro in Unit_hipFreeMipmappedArrayImplicitSyncArray to log more information when there is not enough memory for the mipmapped array to be allocated
* fix formatting

[ROCm/hip-tests commit: 4b2ed7653f]

projects/hip-tests/catch/unit/memory/hipMalloc3D.cc

@@ -59,26 +59,56 @@ static void Malloc3DThreadFunc(int gpu) {
 }
 
 /*
- * This verifies the hipMalloc3D API by
- * assigning width,height and depth as 10
+ * This test allocates via hipMalloc3D and deallotes via hipFree().
+ * To verify that the returned memory is again available, we use hipMemGetInfo().
+ * On Windows, allocating/deallocating small amounts of device memory will not make a difference in
+ * the reported available memory because they go into subheaps of size
+ * PalSettings::subAllocationChunkSize_ and only whenever we trigger a whole subheap
+ *  allocation/deallocation we will see a difference in the reported value.
+ * To make sure we make a difference in the reported available memory; we perform small several
+ * allocation whose combined size goes over PalSettings::subAllocationChunkSize_;
+ * hipMemGetInfo() should indicate the memory went down after we hipFree() all of them
  */
 TEST_CASE("Unit_hipMalloc3D_Basic") {
   CHECK_IMAGE_SUPPORT
 
-  size_t width = SMALL_SIZE * sizeof(char);
-  size_t height{SMALL_SIZE}, depth{SMALL_SIZE};
-  hipPitchedPtr devPitchedPtr;
+  static constexpr int ChunkSize = 64;  // (in megabytes)
+  static constexpr int NumAllocations = 3;
+
+  size_t width{(ChunkSize * 1024) / NumAllocations}, height{1024}, depth{1};
+  hipPitchedPtr devPitchedPtr[NumAllocations];
   hipExtent extent = make_hipExtent(width, height, depth);
-  size_t tot, avail, ptot, pavail;
+  size_t tot, avail, itot, iavail, ptot, pavail;
   HIP_CHECK(hipMemGetInfo(&pavail, &ptot));
 
-  REQUIRE(hipMalloc3D(&devPitchedPtr, extent) == hipSuccess);
-  HIPCHECK(hipFree(devPitchedPtr.ptr));
+  for (int i = 0; i < NumAllocations; i++) {
+    REQUIRE(hipMalloc3D(&devPitchedPtr[i], extent) == hipSuccess);
+  }
+
+  HIP_CHECK(hipMemGetInfo(&iavail, &itot));
+
+  if (iavail >= pavail)
+    WARN(
+        "hipMemGetInfo() did not report increased memory usage after calling hipMalloc3D(). "
+        "Before: "
+        << pavail << " after: " << iavail);
+
+  for (int i = 0; i < NumAllocations; i++) {
+    HIPCHECK(hipFree(devPitchedPtr[i].ptr));
+  }
 
   HIP_CHECK(hipMemGetInfo(&avail, &tot));
 
-  if (pavail != avail) {
-    WARN("Memory leak of hipMalloc3D API in multithreaded scenario");
+  // as the runtime might cache some of the allocations and also it is difficult the
+  // available amount returned is the same as the one we got the first time because of
+  // other processes running on the system; we consider a success if at least a size
+  // equivalent to two of the allocations has become available
+  // This test was too brittle before, when it was expecting avail to be equal to pavail
+  if (avail < pavail - height * width * depth) {
+    WARN("Memory leak of hipMalloc3D API in multithreaded scenario."
+         << " Available memory before the hipMalloc3D() call (bytes): " << pavail
+         << " Available memory after the call: " << iavail
+         << " Available memory after hipFree(): " << avail);
     REQUIRE(false);
   }
 }