diff --git a/projects/hip/include/hcc_detail/hip_hcc.h b/projects/hip/include/hcc_detail/hip_hcc.h
index deb9fd0b04..c0ddf1595a 100644
--- a/projects/hip/include/hcc_detail/hip_hcc.h
+++ b/projects/hip/include/hcc_detail/hip_hcc.h
@@ -450,7 +450,7 @@ private:
     void                        waitCopy(LockedAccessor_StreamCrit_t &crit, ihipSignal_t *signal);
 
     // The unsigned return is hipMemcpyKind
-    unsigned resolveMemcpyDirection(bool srcInDeviceMem, bool dstInDeviceMem);
+    unsigned resolveMemcpyDirection(bool srcTracked, bool dstTracked, bool srcInDeviceMem, bool dstInDeviceMem);
     void setCopyAgents(unsigned kind, ihipCommand_t *commandType, hsa_agent_t *srcAgent, hsa_agent_t *dstAgent);
 
     unsigned                    _device_index;       // index into the g_device array 
diff --git a/projects/hip/src/hip_hcc.cpp b/projects/hip/src/hip_hcc.cpp
index 41469c5ee1..d96d372354 100644
--- a/projects/hip/src/hip_hcc.cpp
+++ b/projects/hip/src/hip_hcc.cpp
@@ -1134,22 +1134,30 @@ void ihipSetTs(hipEvent_t e)
 
 
 // Resolve hipMemcpyDefault to a known type.
-unsigned ihipStream_t::resolveMemcpyDirection(bool srcInDeviceMem, bool dstInDeviceMem)
+unsigned ihipStream_t::resolveMemcpyDirection(bool srcTracked, bool dstTracked, bool srcInDeviceMem, bool dstInDeviceMem)
 {
     hipMemcpyKind kind = hipMemcpyDefault;
-
-    if (!srcInDeviceMem && !dstInDeviceMem) {
+    if(!srcTracked && !dstTracked)
+    {
         kind = hipMemcpyHostToHost;
-    } else if (!srcInDeviceMem && dstInDeviceMem) {
-        kind = hipMemcpyHostToDevice;
-    } else if (srcInDeviceMem && !dstInDeviceMem) {
-        kind = hipMemcpyDeviceToHost;
-    } else if (srcInDeviceMem &&  dstInDeviceMem) {
-        kind = hipMemcpyDeviceToDevice;
+    }
+    if(!srcTracked && dstTracked)
+    {
+        if(dstInDeviceMem) { kind = hipMemcpyHostToDevice; }
+        else{ kind = hipMemcpyHostToHost; }
+    }
+    if (srcTracked && !dstTracked) {
+        if(srcInDeviceMem) { kind = hipMemcpyDeviceToHost; }
+        else { kind = hipMemcpyHostToHost; }
+    }
+    if (srcTracked && dstTracked) {
+        if(srcInDeviceMem && dstInDeviceMem) { kind = hipMemcpyDeviceToDevice; }
+        if(srcInDeviceMem && !dstInDeviceMem) { kind = hipMemcpyDeviceToHost; }
+        if(!srcInDeviceMem && !dstInDeviceMem) { kind = hipMemcpyHostToHost; }
+        if(!srcInDeviceMem && dstInDeviceMem) { kind = hipMemcpyHostToDevice; }
     }
 
     assert (kind != hipMemcpyDefault);
-
     return kind;
 }
 
@@ -1185,17 +1193,16 @@ void ihipStream_t::copySync(LockedAccessor_StreamCrit_t &crit, void* dst, const
     bool dstTracked = (hc::am_memtracker_getinfo(&dstPtrInfo, dst) == AM_SUCCESS);
     bool srcTracked = (hc::am_memtracker_getinfo(&srcPtrInfo, src) == AM_SUCCESS);
 
-
     // Resolve default to a specific Kind so we know which algorithm to use:
     if (kind == hipMemcpyDefault) {
         bool srcInDeviceMem = (srcTracked && srcPtrInfo._isInDeviceMem);
         bool dstInDeviceMem = (dstTracked && dstPtrInfo._isInDeviceMem);
-        kind = resolveMemcpyDirection(srcInDeviceMem, dstInDeviceMem);
+        kind = resolveMemcpyDirection(srcTracked, dstTracked, srcPtrInfo._isInDeviceMem, dstPtrInfo._isInDeviceMem);
     };
 
     hsa_signal_t depSignal;
 
-    if ((kind == hipMemcpyHostToDevice) && (!srcTracked)) {
+    if (kind == hipMemcpyHostToDevice) {
         int depSignalCnt = preCopyCommand(crit, NULL, &depSignal, ihipCommandCopyH2D);
         if (HIP_STAGING_BUFFERS) {
             tprintf(DB_COPY1, "D2H && !dstTracked: staged copy H2D dst=%p src=%p sz=%zu\n", dst, src, sizeBytes);
@@ -1217,7 +1224,7 @@ void ihipStream_t::copySync(LockedAccessor_StreamCrit_t &crit, void* dst, const
             hc::am_copy(dst, src, sizeBytes);
 #endif
         }
-    } else if ((kind == hipMemcpyDeviceToHost) && (!dstTracked)) {
+    } else if (kind == hipMemcpyDeviceToHost) {
         int depSignalCnt = preCopyCommand(crit, NULL, &depSignal, ihipCommandCopyD2H);
         if (HIP_STAGING_BUFFERS) {
             tprintf(DB_COPY1, "D2H && !dstTracked: staged copy D2H dst=%p src=%p sz=%zu\n", dst, src, sizeBytes);
@@ -1323,7 +1330,7 @@ void ihipStream_t::copyAsync(void* dst, const void* src, size_t sizeBytes, unsig
         if (kind == hipMemcpyDefault) {
             bool srcInDeviceMem = (srcTracked && srcPtrInfo._isInDeviceMem);
             bool dstInDeviceMem = (dstTracked && dstPtrInfo._isInDeviceMem);
-            kind = resolveMemcpyDirection(srcInDeviceMem, dstInDeviceMem);
+            kind = resolveMemcpyDirection(srcTracked, dstTracked, srcPtrInfo._isInDeviceMem, dstPtrInfo._isInDeviceMem);
         }
 
 
diff --git a/projects/hip/src/hip_memory.cpp b/projects/hip/src/hip_memory.cpp
index f99ca4eade..dcde66c4c7 100644
--- a/projects/hip/src/hip_memory.cpp
+++ b/projects/hip/src/hip_memory.cpp
@@ -156,10 +156,10 @@ hipError_t hipHostMalloc(void** ptr, size_t sizeBytes, unsigned int flags)
     if(device){
         if(flags == hipHostMallocDefault){
             *ptr = hc::am_alloc(sizeBytes, device->_acc, amHostPinned);
-            if(sizeBytes && (*ptr == NULL)){
+            if(sizeBytes < 1 && (*ptr == NULL)){
                 hip_status = hipErrorMemoryAllocation;
             }else{
-                hc::am_memtracker_update(*ptr, device->_device_index, 0);
+                hc::am_memtracker_update(*ptr, device->_device_index, amHostPinned);
             }
             tprintf(DB_MEM, " %s: pinned ptr=%p\n", __func__, *ptr);
         } else if(flags & hipHostMallocMapped){
diff --git a/projects/hip/src/hip_peer.cpp b/projects/hip/src/hip_peer.cpp
index d45f95dc6c..900f2a6efb 100644
--- a/projects/hip/src/hip_peer.cpp
+++ b/projects/hip/src/hip_peer.cpp
@@ -40,11 +40,7 @@ hipError_t hipDeviceCanAccessPeer (int* canAccessPeer, int  deviceId, int peerDe
         if (deviceId == peerDeviceId) {
             *canAccessPeer = 0;
         } else {
-#if USE_PEER_TO_PEER>=2
             *canAccessPeer = peerDevice->_acc.get_is_peer(thisDevice->_acc);
-#else
-            *canAccessPeer = 0;
-#endif
         }
 
     } else {
@@ -67,11 +63,7 @@ hipError_t hipDeviceDisablePeerAccess (int peerDeviceId)
     auto thisDevice = ihipGetTlsDefaultDevice();
     auto peerDevice = ihipGetDevice(peerDeviceId);
     if ((thisDevice != NULL) && (peerDevice != NULL)) {
-#if USE_PEER_TO_PEER>=2
         bool canAccessPeer =  peerDevice->_acc.get_is_peer(thisDevice->_acc);
-#else
-        bool canAccessPeer = 0;
-#endif
         if (! canAccessPeer) {
             err = hipErrorInvalidDevice;  // P2P not allowed between these devices.
         } else if (thisDevice == peerDevice)  {
@@ -80,10 +72,8 @@ hipError_t hipDeviceDisablePeerAccess (int peerDeviceId)
             LockedAccessor_DeviceCrit_t crit(thisDevice->criticalData());
             bool changed = crit->removePeer(peerDevice);
             if (changed) {
-#if USE_PEER_TO_PEER>=3
                 // Update the peers for all memory already saved in the tracker:
                 am_memtracker_update_peers(thisDevice->_acc, crit->peerCnt(), crit->peerAgents());
-#endif
             } else {
                 err = hipErrorPeerAccessNotEnabled; // never enabled P2P access.
             }