This switches HIP from its currently convoluted macro + pfe based dispatch mechanism to a more natural one partially based on the existing module API. The basic idea is that HCC will always correctly emit __global__ functions: as empty-bodied stubs, on host, and as kernels, on device. It then becomes trivial to obtain the mangled name on host, at dispatch, from the function's address, and then to use the mangled name to retrieve the kernel. This should address all problems stemming from serialisation, dubious mismatches due to the manufactured functor, macro-isms et al. It also immediately enables support for generalised globals as a consequence of that being available in the module API. Finally, it will make debug much easier, since the actual names of the __global__ functions will automatically be used in traces etc. One detail is that due to how dispatch works now (hipLaunchKernel and hipLaunchKernelGGL are themselves variadic function templates which deduce the function type of the callee), in certain cases it may be necesssary to insert explicit casts to ensure that the variadic argument list selects a viable overload - this can be observed in some unit tests. Eventually we may be able to remove this limitation, but for now it does not appear terribly onerous. The code is not extremely HIPpie, nor is it fully optimised, but rather is intended as a starting point for the HIP team to make its own.

tests/src/runtimeApi/stream/hipNullStream.cpp

@@ -119,7 +119,7 @@ void Streamer<T>::reset()
 {
     HipTest::setDefaultData(_numElements, _A_h, _B_h, _C_h);
     H2D();
-    
+
 }
 
 
@@ -128,7 +128,17 @@ void Streamer<T>::enqueAsync()
 {
     printf ("testing: %s  numElements=%zu size=%6.2fMB\n", __func__, _numElements, _numElements * sizeof(T) / 1024.0/1024.0);
     unsigned blocks = HipTest::setNumBlocks(blocksPerCU, threadsPerBlock, _numElements);
-    hipLaunchKernel(vectorADDRepeat, dim3(blocks), dim3(threadsPerBlock), 0, _stream, _A_d, _B_d, _C_d, _numElements, p_repeat);
+    hipLaunchKernel(
+        vectorADDRepeat,
+        dim3(blocks),
+        dim3(threadsPerBlock),
+        0,
+        _stream,
+        static_cast<const T*>(_A_d),
+        static_cast<const T*>(_B_d),
+        _C_d,
+        _numElements,
+        p_repeat);
 
 }
 
@@ -225,7 +235,17 @@ int main(int argc, char *argv[])
             auto lastStreamer = streamers[s - 1];
 
             // Dispatch to NULL stream, should wait for prior async activity to complete before beginning:
-            hipLaunchKernel(vectorADDRepeat, dim3(blocks), dim3(threadsPerBlock), 0, 0/*nullstream*/, lastStreamer->_C_d, lastStreamer->_C_d, nullStreamer->_C_d, numElements, 1/*repeat*/);
+            hipLaunchKernel(
+                vectorADDRepeat,
+                dim3(blocks),
+                dim3(threadsPerBlock),
+                0,
+                0/*nullstream*/,
+                static_cast<const int*>(lastStreamer->_C_d),
+                static_cast<const int*>(lastStreamer->_C_d),
+                nullStreamer->_C_d,
+                numElements,
+                1/*repeat*/);
 
 
             if (p_db) {
@@ -238,7 +258,7 @@ int main(int argc, char *argv[])
             nullStreamer->D2H();
             HIPCHECK(hipDeviceSynchronize());
 
-            HipTest::checkTest(expected_H, nullStreamer->_C_h, numElements); 
+            HipTest::checkTest(expected_H, nullStreamer->_C_h, numElements);
         }
     }
 
@@ -257,13 +277,23 @@ int main(int argc, char *argv[])
             auto lastStreamer = streamers[s - 1];
 
             // Dispatch to NULL stream, should wait for prior async activity to complete before beginning:
-            hipLaunchKernel(vectorADDRepeat, dim3(blocks), dim3(threadsPerBlock), 0, 0/*nullstream*/, lastStreamer->_C_d, lastStreamer->_C_d, nullStreamer->_C_d, numElements, 1/*repeat*/);
+            hipLaunchKernel(
+                vectorADDRepeat,
+                dim3(blocks),
+                dim3(threadsPerBlock),
+                0,
+                0/*nullstream*/,
+                static_cast<const int*>(lastStreamer->_C_d),
+                static_cast<const int*>(lastStreamer->_C_d),
+                nullStreamer->_C_d,
+                numElements,
+                1/*repeat*/);
 
             nullStreamer->D2H();
 
             HIPCHECK(hipDeviceSynchronize());
 
-            HipTest::checkTest(expected_H, nullStreamer->_C_h, numElements); 
+            HipTest::checkTest(expected_H, nullStreamer->_C_h, numElements);
         }
     }
 
@@ -289,10 +319,10 @@ int main(int argc, char *argv[])
         // Copy with stream1, this could go async if the streamSync doesn't synchronize ALL the streams.
         HIPCHECK(hipMemcpyAsync(streamers[0]->_C_h, streamers[0]->_C_d, streamers[0]->_numElements*sizeof(int), hipMemcpyDeviceToHost, streamers[1]->_stream));
 
-        
+
         HIPCHECK(hipDeviceSynchronize());
 
-        HipTest::checkTest(expected_H, streamers[0]->_C_h, numElements); 
+        HipTest::checkTest(expected_H, streamers[0]->_C_h, numElements);
     }
 
 

tests/src/runtimeApi/stream/hipStreamSync2.cpp

@@ -59,23 +59,23 @@ const char *syncModeString(int syncMode) {
 void test(unsigned testMask, int *C_d, int *C_h, int64_t numElements, SyncMode syncMode, bool expectMismatch)
 {
 
-    // This test sends a long-running kernel to the null stream, then tests to see if the 
+    // This test sends a long-running kernel to the null stream, then tests to see if the
     // specified synchronization technique is effective.
     //
-    // Some syncMode are not expected to correctly sync (for example "syncNone").  in these 
+    // Some syncMode are not expected to correctly sync (for example "syncNone").  in these
     // cases the test sets expectMismatch and the check logic below will attempt to ensure that
     // the undesired synchronization did not occur - ie ensure the kernel is still running and did
     // not yet update the stop event.  This can be tricky since if the kernel runs fast enough it
-    // may complete before the check.  To prevent this, the addCountReverse has a count parameter 
-    // which causes it to loop repeatedly, and the results are checked in reverse order.  
+    // may complete before the check.  To prevent this, the addCountReverse has a count parameter
+    // which causes it to loop repeatedly, and the results are checked in reverse order.
     //
     // Tests with expectMismatch=true should ensure the kernel finishes correctly. This results
     // are checked and we test to make sure stop event has completed.
-    
+
     if (!(testMask & p_tests)) {
         return;
     }
-    printf ("\ntest 0x%02x: syncMode=%s expectMismatch=%d\n", 
+    printf ("\ntest 0x%02x: syncMode=%s expectMismatch=%d\n",
             testMask, syncModeString(syncMode), expectMismatch);
 
     size_t sizeBytes = numElements * sizeof(int);
@@ -97,8 +97,17 @@ void test(unsigned testMask, int *C_d, int *C_h, int64_t numElements, SyncMode s
 
     unsigned blocks = HipTest::setNumBlocks(blocksPerCU, threadsPerBlock, numElements);
     // Launch kernel into null stream, should result in C_h == count.
-    hipLaunchKernelGGL(HipTest::addCountReverse , dim3(blocks), dim3(threadsPerBlock), 0, 0 /*stream*/,    C_d, C_h, numElements, count);
-    HIPCHECK(hipEventRecord(stop, 0/*default*/));  
+    hipLaunchKernelGGL(
+        HipTest::addCountReverse,
+        dim3(blocks),
+        dim3(threadsPerBlock),
+        0,
+        0 /*stream*/,
+        static_cast<const int*>(C_d),
+        C_h,
+        numElements,
+        count);
+    HIPCHECK(hipEventRecord(stop, 0/*default*/));
 
     switch (syncMode) {
         case syncNone:
@@ -108,18 +117,18 @@ void test(unsigned testMask, int *C_d, int *C_h, int64_t numElements, SyncMode s
             break;
         case syncOtherStream:
             // Does this synchronize with the null stream?
-            HIPCHECK(hipStreamSynchronize(otherStream));  
+            HIPCHECK(hipStreamSynchronize(otherStream));
             break;
         case syncMarkerThenOtherStream:
         case syncMarkerThenOtherNonBlockingStream:
-            
-            // this may wait for NULL stream depending hipStreamNonBlocking flag above
-            HIPCHECK(hipEventRecord(otherStreamEvent, otherStream));  
 
-            HIPCHECK(hipStreamSynchronize(otherStream));  
+            // this may wait for NULL stream depending hipStreamNonBlocking flag above
+            HIPCHECK(hipEventRecord(otherStreamEvent, otherStream));
+
+            HIPCHECK(hipStreamSynchronize(otherStream));
             break;
         case syncDevice:
-            HIPCHECK(hipDeviceSynchronize());  
+            HIPCHECK(hipDeviceSynchronize());
             break;
         default:
             assert(0);
@@ -197,7 +206,7 @@ void runTests(int64_t numElements)
 int main(int argc, char *argv[])
 {
     // Can' destroy the default stream:// TODO - move to another test
-    HIPCHECK_API(hipStreamDestroy(0), hipErrorInvalidResourceHandle); 
+    HIPCHECK_API(hipStreamDestroy(0), hipErrorInvalidResourceHandle);
 
     HipTest::parseStandardArguments(argc, argv, true /*failOnUndefinedArg*/);
 

tests/src/runtimeApi/stream/hipStreamWaitEvent.cpp

@@ -88,7 +88,7 @@ private:
 
 template <typename T>
 Streamer<T>::Streamer(int deviceId, T * A_d, size_t numElements, int commandType) :
-    _preA_d(NULL), 
+    _preA_d(NULL),
     _A_d(A_d),
     _deviceId(deviceId),
     _numElements(numElements),
@@ -163,9 +163,27 @@ void Streamer<T>::runAsyncAfter(Streamer<T> *depStreamer, bool waitSameStream)
 
     unsigned blocks = HipTest::setNumBlocks(blocksPerCU, threadsPerBlock, _numElements);
     if (_commandType == COMMAND_ADD_REVERSE) {
-        hipLaunchKernelGGL(HipTest::addCountReverse , dim3(blocks), dim3(threadsPerBlock), 0, _stream,    _A_d, _C_d, _numElements, p_count);
+        hipLaunchKernelGGL(
+            HipTest::addCountReverse,
+            dim3(blocks),
+            dim3(threadsPerBlock),
+            0,
+            _stream,
+            static_cast<const T*>(_A_d),
+            _C_d,
+            static_cast<int64_t>(_numElements),
+            static_cast<int>(p_count));
     } else if (_commandType == COMMAND_ADD_FORWARD) {
-        hipLaunchKernelGGL(HipTest::addCount,         dim3(blocks), dim3(threadsPerBlock), 0, _stream,    _A_d, _C_d, _numElements, p_count);
+        hipLaunchKernelGGL(
+            HipTest::addCount,
+            dim3(blocks),
+            dim3(threadsPerBlock),
+            0,
+            _stream,
+            static_cast<const T*>(_A_d),
+            _C_d,
+            _numElements,
+            static_cast<int>(p_count));
     } else if (_commandType == COMMAND_COPY) {
         HIPCHECK(hipMemcpyAsync(_C_d, _A_d, _numElements * sizeof(T), hipMemcpyDeviceToDevice, _stream));
     } else {
@@ -239,7 +257,7 @@ size_t Streamer<T>::check(int streamerNum, T initValue, T expectedOffset, bool e
     return _mismatchCount;
 }
 
-   
+
 
 //---
 //Parse arguments specific to this test.
@@ -300,7 +318,7 @@ void checkAll(int initValue, std::vector<IntStreamer *> &streamers, std::vector<
     for (int i=0; i<streamers.size(); i++) {
 
         expected += streamers[i]->expectedAdd();
-        
+
         mismatchCount += streamers[i]->check(i+1, initValue, expected, expectPass);
 
     }
@@ -330,7 +348,7 @@ void checkAll(int initValue, std::vector<IntStreamer *> &streamers, std::vector<
 
 void sync_none(void) {};
 
-void sync_allDevices(int numDevices) 
+void sync_allDevices(int numDevices)
 {
     for (int d=0; d<numDevices; d++) {
         HIPCHECK(hipSetDevice(d));
@@ -339,7 +357,7 @@ void sync_allDevices(int numDevices)
 }
 
 
-void sync_queryAllUntilComplete(std::vector<IntStreamer *> streamers) 
+void sync_queryAllUntilComplete(std::vector<IntStreamer *> streamers)
 {
     for (int i=streamers.size()-1; i>=0; i--) {
         streamers[i]->queryUntilComplete();
@@ -347,7 +365,7 @@ void sync_queryAllUntilComplete(std::vector<IntStreamer *> streamers)
 }
 
 
-void sync_streamWaitEvent(hipEvent_t lastEvent, int sideDeviceId, hipStream_t sideStream, bool waitHere) 
+void sync_streamWaitEvent(hipEvent_t lastEvent, int sideDeviceId, hipStream_t sideStream, bool waitHere)
 {
     HIPCHECK(hipSetDevice(sideDeviceId));
 
@@ -389,7 +407,7 @@ int main(int argc, char *argv[])
         initArray_h[i] = initValue;
     }
     HIPCHECK(hipMemcpy(initArray_d, initArray_h, sizeElements, hipMemcpyHostToDevice));
-    
+
 
     int numDevices;
     HIPCHECK(hipGetDeviceCount(&numDevices));
@@ -414,7 +432,7 @@ int main(int argc, char *argv[])
 
 
     // A sideband stream channel that is independent from above.
-    // Used to check to ensure the WaitEvent or other synchronization is working correctly since by default sideStream is 
+    // Used to check to ensure the WaitEvent or other synchronization is working correctly since by default sideStream is
     // asynchronous wrt the other streams.
     std::vector<hipStream_t> sideStreams;
     for (int d=0; d<numDevices; d++) {
@@ -446,7 +464,7 @@ int main(int argc, char *argv[])
 
 
     if (p_tests & 0x1000) {
-        printf ("==> Test 0x1000 simple null stream tests\n"); 
+        printf ("==> Test 0x1000 simple null stream tests\n");
 
         // try some null stream:
         hipStreamQuery(0);
@@ -463,7 +481,7 @@ int main(int argc, char *argv[])
             HIPCHECK(hipEventRecord(e1, s1))
 
             HIPCHECK(hipStreamWaitEvent(hipStream_t(0), e1, 0/*flags*/));
-            
+
             HIPCHECK(hipStreamDestroy(s1));
             HIPCHECK(hipEventDestroy(e1));
         }
@@ -476,11 +494,11 @@ int main(int argc, char *argv[])
             HIPCHECK(hipEventRecord(e1, hipStream_t(0)))
 
             HIPCHECK(hipStreamWaitEvent(s1, e1, 0/*flags*/));
-            
+
             HIPCHECK(hipStreamDestroy(s1));
             HIPCHECK(hipEventDestroy(e1));
         }
-        
+
     }