Merge branch 'privatestaging' into grid_launch

src/hip_hcc.cpp

@@ -181,6 +181,8 @@ void ihipStream_t::wait(LockedAccessor_StreamCrit_t &crit, bool assertQueueEmpty
     // Reset the stream to "empty" - next command will not set up an inpute dependency on any older signal.
     crit->_last_command_type = ihipCommandCopyH2D;
     crit->_last_copy_signal = NULL;
+
+    _depFutures.clear();
 }
 
 
@@ -428,6 +430,9 @@ int ihipStream_t::preCopyCommand(LockedAccessor_StreamCrit_t &crit, ihipSignal_t
             needSync = 1;
             hsa_signal_t *hsaSignal = (static_cast<hsa_signal_t*> (crit->_last_kernel_future.get_native_handle()));
             if (hsaSignal) {
+                // Keep reference to the kernel future in order to keep the
+                // dependent signal alive.
+                _depFutures.push_back(crit->_last_kernel_future);
                 *waitSignal = * hsaSignal;
             } else {
                 assert(0); // if NULL signal, and we return 1, hsa_amd_memory_copy_async will fail.  Confirm this never happens.

src/hip_memory.cpp

@@ -427,10 +427,53 @@ hipError_t hipMemsetAsync(void* dst, int  value, size_t sizeBytes, hipStream_t s
 
 hipError_t hipMemset(void* dst, int  value, size_t sizeBytes )
 {
-    HIP_INIT_API(dst, value, sizeBytes);
-
+    hipStream_t stream = hipStreamNull;
     // TODO - call an ihip memset so HIP_TRACE is correct.
-    return hipMemsetAsync(dst, value, sizeBytes, hipStreamNull);
+    HIP_INIT_API(dst, value, sizeBytes, stream);
+
+    hipError_t e = hipSuccess;
+
+    stream =  ihipSyncAndResolveStream(stream);
+
+    if (stream) {
+        stream->lockopen_preKernelCommand();
+
+        hc::completion_future cf ;
+
+        if ((sizeBytes & 0x3) == 0) {
+            // use a faster dword-per-workitem copy:
+            try {
+                value = value & 0xff;
+                unsigned value32 = (value << 24) | (value << 16) | (value << 8) | (value) ;
+                cf = ihipMemsetKernel<unsigned> (stream, static_cast<unsigned*> (dst), value32, sizeBytes/sizeof(unsigned));
+            }
+            catch (std::exception &ex) {
+                e = hipErrorInvalidValue;
+            }
+        } else {
+            // use a slow byte-per-workitem copy:
+            try {
+                cf = ihipMemsetKernel<char> (stream, static_cast<char*> (dst), value, sizeBytes);
+            }
+            catch (std::exception &ex) {
+                e = hipErrorInvalidValue;
+            }
+        }
+        cf.wait();
+
+        stream->lockclose_postKernelCommand(cf);
+
+
+        if (HIP_LAUNCH_BLOCKING) {
+            tprintf (DB_SYNC, "'%s' LAUNCH_BLOCKING wait for memset [stream:%p].\n", __func__, (void*)stream);
+            cf.wait();
+            tprintf (DB_SYNC, "'%s' LAUNCH_BLOCKING memset completed [stream:%p].\n", __func__, (void*)stream);
+        }
+    } else {
+        e = hipErrorInvalidValue;
+    }
+
+    return ihipLogStatus(e);
 }
 
 

src/hip_peer.cpp

@@ -24,7 +24,7 @@ THE SOFTWARE.
 #include "hcc_detail/trace_helper.h"
 
 /**
- * @warning HCC returns 0 in *canAccessPeer ; Need to update this function when RT supports P2P
+ * HCC returns 0 in *canAccessPeer ; Need to update this function when RT supports P2P
  */
 //---
 hipError_t hipDeviceCanAccessPeer (int* canAccessPeer, int  deviceId, int peerDeviceId)
@@ -145,7 +145,7 @@ hipError_t hipMemcpyPeer (void* dst, int  dstDevice, const void* src, int  srcDe
 
 
 /**
- * @bug This function uses a synchronous copy
+ * This function uses a synchronous copy
  */
 //---
 hipError_t hipMemcpyPeerAsync (void* dst, int  dstDevice, const void* src, int  srcDevice, size_t sizeBytes, hipStream_t stream)