[HIP] Clean-up deprecated HIP error codes

hipErrorMemoryAllocation -> hipErrorOutOfMemory
hipErrorInitializationError -> hipErrorNotInitialized
hipErrorMapBufferObjectFailed -> hipErrorMapFailed
hipErrorInvalidResourceHandle -> hipErrorInvalidHandle


[ROCm/hip commit: 4921678b6c]

projects/hip/src/hip_event.cpp

@@ -103,10 +103,10 @@ hipError_t hipEventCreate(hipEvent_t* event) {
 
 hipError_t hipEventRecord(hipEvent_t event, hipStream_t stream) {
     HIP_INIT_SPECIAL_API(hipEventRecord, TRACE_SYNC, event, stream);
-    if (!event) return ihipLogStatus(hipErrorInvalidResourceHandle);
+    if (!event) return ihipLogStatus(hipErrorInvalidHandle);
     stream = ihipSyncAndResolveStream(stream);
     LockedAccessor_EventCrit_t eCrit(event->criticalData());
-    if (eCrit->_eventData._state == hipEventStatusUnitialized) return ihipLogStatus(hipErrorInvalidResourceHandle);
+    if (eCrit->_eventData._state == hipEventStatusUnitialized) return ihipLogStatus(hipErrorInvalidHandle);
     if (HIP_SYNC_NULL_STREAM && stream->isDefaultStream()) {
         // TODO-HIP_SYNC_NULL_STREAM : can remove this code when HIP_SYNC_NULL_STREAM = 0
         // If default stream , then wait on all queues.
@@ -136,7 +136,7 @@ hipError_t hipEventDestroy(hipEvent_t event) {
 
         return ihipLogStatus(hipSuccess);
     } else {
-        return ihipLogStatus(hipErrorInvalidResourceHandle);
+        return ihipLogStatus(hipErrorInvalidHandle);
     }
 }
 
@@ -152,7 +152,7 @@ hipError_t hipEventSynchronize(hipEvent_t event) {
         auto ecd = event->locked_copyCrit();
 
         if (ecd._state == hipEventStatusUnitialized) {
-            return ihipLogStatus(hipErrorInvalidResourceHandle);
+            return ihipLogStatus(hipErrorInvalidHandle);
         } else if (ecd._state == hipEventStatusCreated) {
             // Created but not actually recorded on any device:
             return ihipLogStatus(hipSuccess);
@@ -167,7 +167,7 @@ hipError_t hipEventSynchronize(hipEvent_t event) {
             return ihipLogStatus(hipSuccess);
         }
     } else {
-        return ihipLogStatus(hipErrorInvalidResourceHandle);
+        return ihipLogStatus(hipErrorInvalidHandle);
     }
 }
 
@@ -175,7 +175,7 @@ hipError_t hipEventElapsedTime(float* ms, hipEvent_t start, hipEvent_t stop) {
     HIP_INIT_API(hipEventElapsedTime, ms, start, stop);
 
     if (ms == nullptr) return ihipLogStatus(hipErrorInvalidValue);
-    if ((start == nullptr) || (stop == nullptr)) return ihipLogStatus(hipErrorInvalidResourceHandle);
+    if ((start == nullptr) || (stop == nullptr)) return ihipLogStatus(hipErrorInvalidHandle);
 
     *ms = 0.0f;
     auto startEcd = start->locked_copyCrit();
@@ -187,8 +187,8 @@ hipError_t hipEventElapsedTime(float* ms, hipEvent_t start, hipEvent_t stop) {
         (stop->_flags & hipEventDisableTiming) ||
         (stopEcd._state == hipEventStatusUnitialized) ||
         (stopEcd._state == hipEventStatusCreated)) {
-        // Both events must be at least recorded else return hipErrorInvalidResourceHandle
-        return ihipLogStatus(hipErrorInvalidResourceHandle);
+        // Both events must be at least recorded else return hipErrorInvalidHandle
+        return ihipLogStatus(hipErrorInvalidHandle);
     }
 
     // Refresh status, if still recording...
@@ -222,7 +222,7 @@ hipError_t hipEventElapsedTime(float* ms, hipEvent_t start, hipEvent_t stop) {
 hipError_t hipEventQuery(hipEvent_t event) {
     HIP_INIT_SPECIAL_API(hipEventQuery, TRACE_QUERY, event);
  
-    if (!event) return ihipLogStatus(hipErrorInvalidResourceHandle);
+    if (!event) return ihipLogStatus(hipErrorInvalidHandle);
 
     if (!(event->_flags & hipEventReleaseToSystem)) {
         tprintf(DB_WARN,

projects/hip/src/hip_hcc.cpp

@@ -1756,13 +1756,8 @@ const char* ihipErrorString(hipError_t hip_error) {
             return "hipErrorIllegalAddress";
         case hipErrorInvalidSymbol:
             return "hipErrorInvalidSymbol";
-
         case hipErrorMissingConfiguration:
             return "hipErrorMissingConfiguration";
-        case hipErrorMemoryAllocation:
-            return "hipErrorMemoryAllocation";
-        case hipErrorInitializationError:
-            return "hipErrorInitializationError";
         case hipErrorLaunchFailure:
             return "hipErrorLaunchFailure";
         case hipErrorPriorLaunchFailure:
@@ -1785,15 +1780,12 @@ const char* ihipErrorString(hipError_t hip_error) {
             return "hipErrorInvalidMemcpyDirection";
         case hipErrorUnknown:
             return "hipErrorUnknown";
-        case hipErrorInvalidResourceHandle:
-            return "hipErrorInvalidResourceHandle";
         case hipErrorNotReady:
             return "hipErrorNotReady";
         case hipErrorNoDevice:
             return "hipErrorNoDevice";
         case hipErrorPeerAccessAlreadyEnabled:
             return "hipErrorPeerAccessAlreadyEnabled";
-
         case hipErrorPeerAccessNotEnabled:
             return "hipErrorPeerAccessNotEnabled";
         case hipErrorRuntimeMemory:
@@ -1804,8 +1796,6 @@ const char* ihipErrorString(hipError_t hip_error) {
             return "hipErrorHostMemoryAlreadyRegistered";
         case hipErrorHostMemoryNotRegistered:
             return "hipErrorHostMemoryNotRegistered";
-        case hipErrorMapBufferObjectFailed:
-            return "hipErrorMapBufferObjectFailed";
         case hipErrorAssert:
             return "hipErrorAssert";
         case hipErrorNotSupported:

projects/hip/src/hip_memory.cpp

@@ -199,7 +199,7 @@ hipError_t ihipHostMalloc(TlsData *tls, void** ptr, size_t sizeBytes, unsigned i
                 true  /*shareWithAll*/, amFlags, flags, 0);
 
             if (sizeBytes && (*ptr == NULL)) {
-                hip_status = hipErrorMemoryAllocation;
+                hip_status = hipErrorOutOfMemory;
             }
         }
     }
@@ -328,7 +328,7 @@ hipError_t hipHostGetDevicePointer(void** devicePointer, void* hostPointer, unsi
             tprintf(DB_MEM, " host_ptr=%p returned device_pointer=%p\n", hostPointer,
                     *devicePointer);
         } else {
-            e = hipErrorMemoryAllocation;
+            e = hipErrorOutOfMemory;
         }
     }
     return ihipLogStatus(e);
@@ -354,7 +354,7 @@ hipError_t hipMalloc(void** ptr, size_t sizeBytes) {
                                               0 /*amFlags*/, 0 /*hipFlags*/, 0);
 
         if (sizeBytes && (*ptr == NULL)) {
-            hip_status = hipErrorMemoryAllocation;
+            hip_status = hipErrorOutOfMemory;
         }
     }
 
@@ -389,11 +389,11 @@ hipError_t hipExtMallocWithFlags(void** ptr, size_t sizeBytes, unsigned int flag
                                               amFlags /*amFlags*/, 0 /*hipFlags*/, 0);
 
         if (sizeBytes && (*ptr == NULL)) {
-            hip_status = hipErrorMemoryAllocation;
+            hip_status = hipErrorOutOfMemory;
         }
     }
 #else
-    hipError_t hip_status = hipErrorMemoryAllocation;
+    hipError_t hip_status = hipErrorOutOfMemory;
 #endif
 
     return ihipLogStatus(hip_status);
@@ -436,7 +436,7 @@ hipError_t allocImage(TlsData* tls,hsa_ext_image_geometry_t geometry, int width,
       hc::accelerator acc = ctx->getDevice()->_acc;
       hsa_agent_t* agent = static_cast<hsa_agent_t*>(acc.get_hsa_agent());
       if (!agent)
-         return hipErrorInvalidResourceHandle;
+         return hipErrorInvalidHandle;
       size_t allocGranularity = 0;
       hsa_amd_memory_pool_t* allocRegion = static_cast<hsa_amd_memory_pool_t*>(acc.get_hsa_am_region());
       hsa_amd_memory_pool_get_info(*allocRegion, HSA_AMD_MEMORY_POOL_INFO_RUNTIME_ALLOC_GRANULE, &allocGranularity);
@@ -461,12 +461,12 @@ hipError_t allocImage(TlsData* tls,hsa_ext_image_geometry_t geometry, int width,
       *ptr = hip_internal::allocAndSharePtr("device_array", imageInfo.size, ctx,
                                                                           false /*shareWithAll*/, am_flags, 0, alignment);
       if (*ptr == NULL) {
-         return hipErrorMemoryAllocation;
+         return hipErrorOutOfMemory;
       }
       return hipSuccess;
    }
    else {
-      return hipErrorMemoryAllocation;
+      return hipErrorOutOfMemory;
    }
 }
 
@@ -565,7 +565,7 @@ hipError_t GetImageInfo(hsa_ext_image_geometry_t geometry,int width, int height,
     hc::accelerator acc;
     hsa_agent_t* agent = static_cast<hsa_agent_t*>(acc.get_hsa_agent());
     if (!agent)
-        return hipErrorInvalidResourceHandle;
+        return hipErrorInvalidHandle;
     hsa_status_t status =
         hsa_ext_image_data_get_info_with_layout(*agent, &imageDescriptor, permission, HSA_EXT_IMAGE_DATA_LAYOUT_LINEAR, 0, 0, &imageInfo);
     if(HSA_STATUS_SUCCESS != status){
@@ -860,7 +860,7 @@ hipError_t hipHostRegister(void* hostPtr, size_t sizeBytes, unsigned int flags)
                 if (am_status == AM_SUCCESS) {
                     hip_status = hipSuccess;
                 } else {
-                    hip_status = hipErrorMemoryAllocation;
+                    hip_status = hipErrorOutOfMemory;
                 }
             } else {
                 hip_status = hipErrorInvalidValue;
@@ -2083,7 +2083,7 @@ hipError_t hipIpcGetMemHandle(hipIpcMemHandle_t* handle, void* devPtr) {
     size_t psize = 0u;
     hc::accelerator acc;
     if ((handle == NULL) || (devPtr == NULL)) {
-        hipStatus = hipErrorInvalidResourceHandle;
+        hipStatus = hipErrorInvalidHandle;
     } else {
 #if (__hcc_workweek__ >= 17332)
         hc::AmPointerInfo amPointerInfo(NULL, NULL, NULL, 0, acc, 0, 0);
@@ -2094,7 +2094,7 @@ hipError_t hipIpcGetMemHandle(hipIpcMemHandle_t* handle, void* devPtr) {
         if (status == AM_SUCCESS) {
             psize = (size_t)amPointerInfo._sizeBytes;
         } else {
-            hipStatus = hipErrorInvalidResourceHandle;
+            hipStatus = hipErrorInvalidHandle;
         }
         ihipIpcMemHandle_t* iHandle = (ihipIpcMemHandle_t*)handle;
         // Save the size of the pointer to hipIpcMemHandle
@@ -2104,7 +2104,7 @@ hipError_t hipIpcGetMemHandle(hipIpcMemHandle_t* handle, void* devPtr) {
         // Create HSA ipc memory
         hsa_status_t hsa_status =
             hsa_amd_ipc_memory_create(devPtr, psize, (hsa_amd_ipc_memory_t*)&(iHandle->ipc_handle));
-        if (hsa_status != HSA_STATUS_SUCCESS) hipStatus = hipErrorMemoryAllocation;
+        if (hsa_status != HSA_STATUS_SUCCESS) hipStatus = hipErrorOutOfMemory;
 #else
         hipStatus = hipErrorRuntimeOther;
 #endif
@@ -2123,7 +2123,7 @@ hipError_t hipIpcOpenMemHandle(void** devPtr, hipIpcMemHandle_t handle, unsigned
     hc::accelerator acc;
     hsa_agent_t* agent = static_cast<hsa_agent_t*>(acc.get_hsa_agent());
     if (!agent)
-        return ihipLogStatus(hipErrorInvalidResourceHandle);
+        return ihipLogStatus(hipErrorInvalidHandle);
 
     ihipIpcMemHandle_t* iHandle = (ihipIpcMemHandle_t*)&handle;
     // Attach ipc memory
@@ -2140,7 +2140,7 @@ hipError_t hipIpcOpenMemHandle(void** devPtr, hipIpcMemHandle_t handle, unsigned
         hc::AmPointerInfo ampi(NULL, *devPtr, *devPtr, sizeof(*devPtr), acc, true, true);
         am_status_t am_status = hc::am_memtracker_add(*devPtr,ampi);
         if (am_status != AM_SUCCESS)
-            return ihipLogStatus(hipErrorMapBufferObjectFailed);
+            return ihipLogStatus(hipErrorMapFailed);
 
 #if USE_APP_PTR_FOR_CTX
         am_status = hc::am_memtracker_update(*devPtr, device->_deviceId, 0, ctx);
@@ -2148,7 +2148,7 @@ hipError_t hipIpcOpenMemHandle(void** devPtr, hipIpcMemHandle_t handle, unsigned
         am_status = hc::am_memtracker_update(*devPtr, device->_deviceId, 0);
 #endif
         if(am_status != AM_SUCCESS)
-            return ihipLogStatus(hipErrorMapBufferObjectFailed);
+            return ihipLogStatus(hipErrorMapFailed);
     }
 #else
     hipStatus = hipErrorRuntimeOther;
@@ -2168,7 +2168,7 @@ hipError_t hipIpcCloseMemHandle(void* devPtr) {
         return ihipLogStatus(hipErrorInvalidValue);
 
     if (hsa_amd_ipc_memory_detach(devPtr) != HSA_STATUS_SUCCESS)
-        return ihipLogStatus(hipErrorInvalidResourceHandle);
+        return ihipLogStatus(hipErrorInvalidHandle);
 #else
     hipStatus = hipErrorRuntimeOther;
 #endif

projects/hip/src/hip_stream.cpp

@@ -133,7 +133,7 @@ hipError_t hipStreamWaitEvent(hipStream_t stream, hipEvent_t event, unsigned int
     hipError_t e = hipSuccess;
 
     if (event == nullptr) {
-        e = hipErrorInvalidResourceHandle;
+        e = hipErrorInvalidHandle;
 
     } else {
         auto ecd = event->locked_copyCrit(); 
@@ -189,7 +189,7 @@ hipError_t hipStreamSynchronize(hipStream_t stream) {
 
 //---
 /**
- * @return #hipSuccess, #hipErrorInvalidResourceHandle
+ * @return #hipSuccess, #hipErrorInvalidHandle
  */
 hipError_t hipStreamDestroy(hipStream_t stream) {
     HIP_INIT_API(hipStreamDestroy, stream);
@@ -199,7 +199,7 @@ hipError_t hipStreamDestroy(hipStream_t stream) {
     //--- Drain the stream:
     if (stream == NULL) {
         if (!HIP_FORCE_NULL_STREAM) {
-            e = hipErrorInvalidResourceHandle;
+            e = hipErrorInvalidHandle;
         }
     } else {
         stream->locked_wait();
@@ -210,7 +210,7 @@ hipError_t hipStreamDestroy(hipStream_t stream) {
             ctx->locked_removeStream(stream);
             delete stream;
         } else {
-            e = hipErrorInvalidResourceHandle;
+            e = hipErrorInvalidHandle;
         }
     }
 
@@ -225,7 +225,7 @@ hipError_t hipStreamGetFlags(hipStream_t stream, unsigned int* flags) {
     if (flags == NULL) {
         return ihipLogStatus(hipErrorInvalidValue);
     } else if (stream == hipStreamNull) {
-        return ihipLogStatus(hipErrorInvalidResourceHandle);
+        return ihipLogStatus(hipErrorInvalidHandle);
     } else {
         *flags = stream->_flags;
         return ihipLogStatus(hipSuccess);
@@ -240,7 +240,7 @@ hipError_t hipStreamGetPriority(hipStream_t stream, int* priority) {
     if (priority == NULL) {
         return ihipLogStatus(hipErrorInvalidValue);
     } else if (stream == hipStreamNull) {
-        return ihipLogStatus(hipErrorInvalidResourceHandle);
+        return ihipLogStatus(hipErrorInvalidHandle);
     } else {
 #if defined(__HCC__) && (__hcc_major__ < 3) && (__hcc_minor__ < 3)
         *priority = 0;