Merge remote-tracking branch 'origin/develop' into cderb/gtest_package

ROCm · Dec 18, 2023 · 48a16ba · 48a16ba
2 parents d13348e + c5a2384
commit 48a16ba
Show file tree

Hide file tree

Showing 47 changed files with 1,678 additions and 847 deletions.
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -381,9 +381,7 @@ if(MIOPEN_USE_HIPRTC)
     if(NOT MIOPEN_USE_COMGR)
         message(FATAL_ERROR "HIPRTC can be used only together with COMGR")
     endif()
-    if(WIN32)
-        find_package(hiprtc REQUIRED)
-    endif()
+    find_package(hiprtc REQUIRED)
     message(STATUS "Build with HIPRTC")
 endif()
 

diff --git a/driver/gemm_driver.hpp b/driver/gemm_driver.hpp
@@ -143,7 +143,8 @@ class GemmDriver : public Driver
 
     T alpha, beta;
 
-    miopen::GemmDescriptor gemm_desc;
+    miopen::GemmDescriptor gemm_desc = {
+        false, false, false, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1.0f, 0.0f, miopenFloat, false};
 };
 
 template <typename T>
@@ -198,13 +199,13 @@ int GemmDriver<T>::GetandSetData()
     gemm_desc.a_cast_type = data_type;
     gemm_desc.b_cast_type = data_type;
 
-    gemm_desc.isColMajor = inflags.GetValueInt("isColMajor");
+    gemm_desc.isColMajor = inflags.GetValueInt("isColMajor") != 0;
     gemm_desc.m          = inflags.GetValueInt("a_h");
     gemm_desc.k          = inflags.GetValueInt("a_w");
     gemm_desc.n          = inflags.GetValueInt("b_w");
 
-    gemm_desc.transA = inflags.GetValueInt("transA");
-    gemm_desc.transB = inflags.GetValueInt("transB");
+    gemm_desc.transA = inflags.GetValueInt("transA") != 0;
+    gemm_desc.transB = inflags.GetValueInt("transB") != 0;
 
     gemm_desc.alpha = inflags.GetValueDouble("alpha");
     gemm_desc.beta  = inflags.GetValueDouble("beta");
@@ -225,6 +226,7 @@ int GemmDriver<T>::GetandSetData()
     gemm_desc.strideB = gemm_desc.k * gemm_desc.n;
     gemm_desc.strideC = gemm_desc.m * gemm_desc.n;
 
+    gemm_desc.deterministic = false;
     return (0);
 }
 

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
@@ -761,8 +761,12 @@ if( MIOPEN_BACKEND STREQUAL "OpenCL")
 elseif(MIOPEN_BACKEND STREQUAL "HIPOC" OR MIOPEN_BACKEND STREQUAL "HIP")
     target_link_libraries( MIOpen PRIVATE hip::device )
     target_link_libraries( MIOpen INTERFACE hip::host )
-    if(MIOPEN_USE_HIPRTC AND WIN32)
-        target_link_libraries( MIOpen PRIVATE hiprtc::hiprtc )
+    if(MIOPEN_USE_HIPRTC)
+        if(WIN32) 
+            target_link_libraries( MIOpen PRIVATE hiprtc::hiprtc )
+        else()
+            target_link_libraries( MIOpen PRIVATE hiprtc)
+        endif()
     endif()
     if(ENABLE_HIP_WORKAROUNDS)
         # Workaround hip not setting its usage requirements correctly

diff --git a/src/activ_api.cpp b/src/activ_api.cpp
@@ -60,7 +60,7 @@ extern "C" miopenStatus_t miopenGetActivationDescriptor(miopenActivationDescript
                                                         double* activGamma)
 {
 
-    MIOPEN_LOG_FUNCTION(activDesc, mode, activAlpha, activBeta, activGamma);
+    MIOPEN_LOG_FUNCTION(activDesc);
     return miopen::try_([&] {
         *mode       = miopen::deref(activDesc).GetMode();
         *activAlpha = miopen::deref(activDesc).GetAlpha();

diff --git a/src/api/find2_0_commons.cpp b/src/api/find2_0_commons.cpp
@@ -354,7 +354,7 @@ miopenStatus_t miopenSaveSolution(miopenSolution_t solution, char* data)
 
 miopenStatus_t miopenGetSolutionSize(miopenSolution_t solution, size_t* size)
 {
-    MIOPEN_LOG_FUNCTION(solution, size);
+    MIOPEN_LOG_FUNCTION(solution);
 
     return miopen::try_([&] {
         if(size == nullptr)
@@ -374,7 +374,7 @@ miopenStatus_t miopenGetSolutionSize(miopenSolution_t solution, size_t* size)
 
 miopenStatus_t miopenGetSolutionWorkspaceSize(miopenSolution_t solution, size_t* workspaceSize)
 {
-    MIOPEN_LOG_FUNCTION(solution, workspaceSize);
+    MIOPEN_LOG_FUNCTION(solution);
 
     return miopen::try_([&] {
         const auto& solution_deref = miopen::deref(solution);
@@ -384,7 +384,7 @@ miopenStatus_t miopenGetSolutionWorkspaceSize(miopenSolution_t solution, size_t*
 
 miopenStatus_t miopenGetSolutionTime(miopenSolution_t solution, float* time)
 {
-    MIOPEN_LOG_FUNCTION(solution, time);
+    MIOPEN_LOG_FUNCTION(solution);
 
     return miopen::try_([&] {
         const auto& solution_deref = miopen::deref(solution);
@@ -394,7 +394,7 @@ miopenStatus_t miopenGetSolutionTime(miopenSolution_t solution, float* time)
 
 miopenStatus_t miopenGetSolutionSolverId(miopenSolution_t solution, uint64_t* solverId)
 {
-    MIOPEN_LOG_FUNCTION(solution, solverId);
+    MIOPEN_LOG_FUNCTION(solution);
 
     return miopen::try_([&] {
         const auto& solution_deref = miopen::deref(solution);
@@ -404,7 +404,7 @@ miopenStatus_t miopenGetSolutionSolverId(miopenSolution_t solution, uint64_t* so
 
 miopenStatus_t miopenGetSolverIdConvAlgorithm(uint64_t solverId, miopenConvAlgorithm_t* result)
 {
-    MIOPEN_LOG_FUNCTION(solverId, result);
+    MIOPEN_LOG_FUNCTION(solverId);
 
     return miopen::try_([&] {
         const auto id_deref = miopen::solver::Id{solverId};

diff --git a/src/convolution_api.cpp b/src/convolution_api.cpp
@@ -166,7 +166,7 @@ extern "C" miopenStatus_t miopenInitConvolutionNdDescriptor(miopenConvolutionDes
 extern "C" miopenStatus_t miopenGetConvolutionGroupCount(miopenConvolutionDescriptor_t convDesc,
                                                          int* groupCount)
 {
-    MIOPEN_LOG_FUNCTION(convDesc, groupCount);
+    MIOPEN_LOG_FUNCTION(convDesc);
     return miopen::try_([&] { miopen::deref(groupCount) = miopen::deref(convDesc).group_count; });
 }
 
@@ -254,7 +254,7 @@ extern "C" miopenStatus_t miopenGetConvolutionDescriptor(miopenConvolutionDescri
                                                          int* dilation_h,
                                                          int* dilation_w)
 {
-    MIOPEN_LOG_FUNCTION(convDesc, c_mode, pad_h, pad_w, stride_h, stride_w, dilation_h, dilation_w);
+    MIOPEN_LOG_FUNCTION(convDesc);
     return miopen::try_([&] {
         if(miopen::deref(convDesc).GetSpatialDimension() != 2)
         {
@@ -279,8 +279,7 @@ extern "C" miopenStatus_t miopenGetConvolutionNdDescriptor(miopenConvolutionDesc
                                                            int* dilationA,
                                                            miopenConvolutionMode_t* c_mode)
 {
-    MIOPEN_LOG_FUNCTION(
-        convDesc, requestedSpatialDim, spatialDim, padA, strideA, dilationA, c_mode);
+    MIOPEN_LOG_FUNCTION(convDesc, requestedSpatialDim);
     return miopen::try_([&] {
         int spatial_dim = miopen::deref(convDesc).GetSpatialDimension();
         if(spatial_dim < requestedSpatialDim)
@@ -305,7 +304,7 @@ extern "C" miopenStatus_t miopenGetConvolutionNdDescriptor(miopenConvolutionDesc
 extern "C" miopenStatus_t miopenGetConvolutionSpatialDim(miopenConvolutionDescriptor_t convDesc,
                                                          int* spatialDim)
 {
-    MIOPEN_LOG_FUNCTION(convDesc, spatialDim);
+    MIOPEN_LOG_FUNCTION(convDesc);
     return miopen::try_(
         [&] { miopen::deref(spatialDim) = miopen::deref(convDesc).GetSpatialDimension(); });
 }
@@ -319,7 +318,7 @@ miopenGetConvolutionForwardOutputDim(miopenConvolutionDescriptor_t convDesc,
                                      int* h,
                                      int* w)
 {
-    MIOPEN_LOG_FUNCTION(convDesc, inputTensorDesc, filterDesc, n, c, h, w);
+    MIOPEN_LOG_FUNCTION(convDesc, inputTensorDesc, filterDesc);
     return miopen::try_([&] {
         if(miopen::deref(convDesc).GetSpatialDimension() != 2)
         {
@@ -340,7 +339,7 @@ miopenGetConvolutionNdForwardOutputDim(miopenConvolutionDescriptor_t convDesc,
                                        int* nDim,
                                        int* outputTensorDimA)
 {
-    MIOPEN_LOG_FUNCTION(convDesc, inputTensorDesc, filterDesc, nDim, outputTensorDimA);
+    MIOPEN_LOG_FUNCTION(convDesc, inputTensorDesc, filterDesc);
     return miopen::try_([&] {
         auto out_desc = miopen::deref(convDesc).GetForwardOutputTensor(
             miopen::deref(inputTensorDesc), miopen::deref(filterDesc));
@@ -369,7 +368,7 @@ miopenConvolutionForwardGetWorkSpaceSize(miopenHandle_t handle,
                                          size_t* workSpaceSize)
 {
 
-    MIOPEN_LOG_FUNCTION(handle, wDesc, xDesc, convDesc, yDesc, workSpaceSize);
+    MIOPEN_LOG_FUNCTION(handle, wDesc, xDesc, convDesc, yDesc);
     return miopen::try_([&] {
         auto ctx               = ExecutionContext{};
         auto problem           = ProblemDescription{};
@@ -690,7 +689,7 @@ miopenConvolutionForwardGetSolutionWorkspaceSize(miopenHandle_t handle,
                                                  const uint64_t solution_id,
                                                  size_t* workSpaceSize)
 {
-    MIOPEN_LOG_FUNCTION(handle, wDesc, xDesc, convDesc, yDesc, solution_id, workSpaceSize);
+    MIOPEN_LOG_FUNCTION(handle, wDesc, xDesc, convDesc, yDesc, solution_id);
     return miopen::try_([&] {
         if(miopen::deref(convDesc).mode == miopenTranspose)
         {
@@ -806,7 +805,7 @@ miopenConvolutionBackwardDataGetSolution(miopenHandle_t handle,
                                          size_t* solutionCount,
                                          miopenConvSolution_t* solutions)
 {
-    MIOPEN_LOG_FUNCTION(handle, dyDesc, wDesc, convDesc, dxDesc, maxSolutionCount, solutionCount);
+    MIOPEN_LOG_FUNCTION(handle, dyDesc, wDesc, convDesc, dxDesc, maxSolutionCount);
     return miopen::try_([&] {
         auto ctx               = ExecutionContext{};
         auto problem           = ProblemDescription{};
@@ -829,7 +828,7 @@ miopenConvolutionBackwardDataGetSolutionWorkspaceSize(miopenHandle_t handle,
                                                       const uint64_t solution_id,
                                                       size_t* workSpaceSize)
 {
-    MIOPEN_LOG_FUNCTION(handle, dyDesc, wDesc, convDesc, dxDesc, solution_id, workSpaceSize);
+    MIOPEN_LOG_FUNCTION(handle, dyDesc, wDesc, convDesc, dxDesc, solution_id);
     return miopen::try_([&] {
         if(miopen::deref(convDesc).mode == miopenTranspose)
         {
@@ -924,7 +923,7 @@ miopenConvolutionBackwardWeightsGetSolutionCount(miopenHandle_t handle,
                                                  const miopenTensorDescriptor_t dwDesc,
                                                  size_t* solutionCount)
 {
-    MIOPEN_LOG_FUNCTION(handle, dyDesc, xDesc, convDesc, dwDesc, solutionCount);
+    MIOPEN_LOG_FUNCTION(handle, dyDesc, xDesc, convDesc, dwDesc);
     return miopen::try_([&] {
         auto ctx               = ExecutionContext{};
         auto problem           = ProblemDescription{};
@@ -944,7 +943,7 @@ miopenConvolutionBackwardWeightsGetSolution(miopenHandle_t handle,
                                             size_t* solutionCount,
                                             miopenConvSolution_t* solutions)
 {
-    MIOPEN_LOG_FUNCTION(handle, dyDesc, xDesc, convDesc, dwDesc, maxSolutionCount, solutionCount);
+    MIOPEN_LOG_FUNCTION(handle, dyDesc, xDesc, convDesc, dwDesc, maxSolutionCount);
     return miopen::try_([&] {
         auto ctx               = ExecutionContext{};
         auto problem           = ProblemDescription{};
@@ -967,7 +966,7 @@ extern "C" miopenStatus_t miopenConvolutionBackwardWeightsGetSolutionWorkspaceSi
     const uint64_t solution_id,
     size_t* workSpaceSize)
 {
-    MIOPEN_LOG_FUNCTION(handle, dyDesc, xDesc, convDesc, dwDesc, solution_id, workSpaceSize);
+    MIOPEN_LOG_FUNCTION(handle, dyDesc, xDesc, convDesc, dwDesc, solution_id);
     return miopen::try_([&] {
         if(miopen::deref(convDesc).mode == miopenTranspose)
         {
@@ -1208,8 +1207,7 @@ miopenConvolutionBackwardDataGetWorkSpaceSize(miopenHandle_t handle,
                                               const miopenTensorDescriptor_t dxDesc,
                                               size_t* workSpaceSize)
 {
-
-    MIOPEN_LOG_FUNCTION(handle, dyDesc, wDesc, convDesc, dxDesc, workSpaceSize);
+    MIOPEN_LOG_FUNCTION(handle, dyDesc, wDesc, convDesc, dxDesc);
     return miopen::try_([&] {
         auto ctx               = ExecutionContext{};
         auto problem           = ProblemDescription{};
@@ -1226,8 +1224,7 @@ miopenConvolutionBackwardWeightsGetWorkSpaceSize(miopenHandle_t handle,
                                                  const miopenTensorDescriptor_t dwDesc,
                                                  size_t* workSpaceSize)
 {
-
-    MIOPEN_LOG_FUNCTION(handle, dyDesc, xDesc, convDesc, dwDesc, workSpaceSize);
+    MIOPEN_LOG_FUNCTION(handle, dyDesc, xDesc, convDesc, dwDesc);
     return miopen::try_([&] {
         auto ctx               = ExecutionContext{};
         auto problem           = ProblemDescription{};
@@ -1378,7 +1375,7 @@ extern "C" miopenStatus_t miopenGetConvolutionAttribute(miopenConvolutionDescrip
                                                         const miopenConvolutionAttrib_t attr,
                                                         int* const value)
 {
-    MIOPEN_LOG_FUNCTION(convDesc, attr, value);
+    MIOPEN_LOG_FUNCTION(convDesc, attr);
     return miopen::try_(
         [&] { miopen::deref(value) = miopen::deref(convDesc).attribute.Get(attr); });
 }
diff --git a/src/ctc_api.cpp b/src/ctc_api.cpp
@@ -48,7 +48,7 @@ extern "C" miopenStatus_t miopenGetCTCLossDescriptor(miopenCTCLossDescriptor_t c
                                                      int* blank_label_id       = nullptr,
                                                      bool* apply_softmax_layer = nullptr)
 {
-    MIOPEN_LOG_FUNCTION(ctcLossDesc, dataType, blank_label_id, apply_softmax_layer);
+    MIOPEN_LOG_FUNCTION(ctcLossDesc);
     return miopen::try_([&] {
         miopen::deref(dataType) = miopen::deref(ctcLossDesc).dataType;
         if(blank_label_id != nullptr)
@@ -82,14 +82,8 @@ miopenGetCTCLossWorkspaceSize(miopenHandle_t handle,
                               const miopenCTCLossDescriptor_t ctcLossDesc,
                               size_t* workSpaceSize)
 {
-    MIOPEN_LOG_FUNCTION(probsDesc,
-                        gradientsDesc,
-                        labels,
-                        labelLengths,
-                        inputLengths,
-                        algo,
-                        ctcLossDesc,
-                        workSpaceSize);
+    MIOPEN_LOG_FUNCTION(
+        probsDesc, gradientsDesc, labels, labelLengths, inputLengths, algo, ctcLossDesc);
 
     return miopen::try_([&] {
         miopen::deref(workSpaceSize) = miopen::deref(ctcLossDesc)

diff --git a/src/dropout_api.cpp b/src/dropout_api.cpp
@@ -39,16 +39,14 @@ extern "C" miopenStatus_t miopenCreateDropoutDescriptor(miopenDropoutDescriptor_
 
 extern "C" miopenStatus_t miopenDestroyDropoutDescriptor(miopenDropoutDescriptor_t dropoutDesc)
 {
-
     MIOPEN_LOG_FUNCTION(dropoutDesc);
     return miopen::try_([&] { miopen_destroy_object(dropoutDesc); });
 }
 
 extern "C" miopenStatus_t miopenDropoutGetReserveSpaceSize(const miopenTensorDescriptor_t xDesc,
                                                            size_t* reserveSpaceSizeInBytes)
 {
-
-    MIOPEN_LOG_FUNCTION(xDesc, reserveSpaceSizeInBytes);
+    MIOPEN_LOG_FUNCTION(xDesc);
     return miopen::try_([&] {
         miopen::deref(reserveSpaceSizeInBytes) =
             miopen::deref(xDesc).GetElementSize() * sizeof(bool);
@@ -58,8 +56,7 @@ extern "C" miopenStatus_t miopenDropoutGetReserveSpaceSize(const miopenTensorDes
 extern "C" miopenStatus_t miopenDropoutGetStatesSize(miopenHandle_t handle,
                                                      size_t* stateSizeInBytes)
 {
-
-    MIOPEN_LOG_FUNCTION(stateSizeInBytes);
+    MIOPEN_LOG_FUNCTION(handle);
     return miopen::try_([&] {
         miopen::deref(stateSizeInBytes) =
             std::min(size_t(MAX_PRNG_STATE), miopen::deref(handle).GetImage3dMaxWidth()) *
@@ -76,7 +73,7 @@ extern "C" miopenStatus_t miopenGetDropoutDescriptor(miopenDropoutDescriptor_t d
                                                      bool* state_evo,
                                                      miopenRNGType_t* rng_mode)
 {
-    MIOPEN_LOG_FUNCTION(dropoutDesc, dropout, states, seed, use_mask, state_evo);
+    MIOPEN_LOG_FUNCTION(dropoutDesc);
     return miopen::try_([&] {
         miopen::deref(dropout)   = miopen::deref(dropoutDesc).dropout;
         miopen::deref(states)    = &(miopen::deref(dropoutDesc).pstates);

diff --git a/src/fused_api.cpp b/src/fused_api.cpp
@@ -87,7 +87,7 @@ miopenFusionPlanGetWorkSpaceSize(miopenHandle_t handle,
                                  size_t* workSpaceSize,
                                  miopenConvFwdAlgorithm_t algo)
 {
-    MIOPEN_LOG_FUNCTION(handle, fusePlanDesc, workSpaceSize);
+    MIOPEN_LOG_FUNCTION(handle, fusePlanDesc, algo);
     miopenStatus_t res = miopenStatusUnknownError;
     miopen::try_([&] {
         size_t sz;
@@ -103,7 +103,7 @@ miopenFusionPlanConvolutionGetAlgo(miopenFusionPlanDescriptor_t fusePlanDesc,
                                    int* returnedAlgoCount,
                                    miopenConvFwdAlgorithm_t* returnedAlgos)
 {
-    MIOPEN_LOG_FUNCTION(fusePlanDesc, requestAlgoCount, returnedAlgoCount, returnedAlgos);
+    MIOPEN_LOG_FUNCTION(fusePlanDesc, requestAlgoCount);
     miopenStatus_t res = miopenStatusUnknownError;
     miopen::try_([&] {
         int cnt = 0;

diff --git a/src/include/miopen/gemm_v2.hpp b/src/include/miopen/gemm_v2.hpp
@@ -77,7 +77,7 @@ struct GemmDescriptor
     miopenDataType_t a_cast_type;
     miopenDataType_t b_cast_type;
     ConvolutionAttribute conv_attributes;
-    GemmDescriptor() {}
+    GemmDescriptor() = delete;
     GemmDescriptor(bool isColMajor_,
                    bool transA_,
                    bool transB_,

diff --git a/src/lrn_api.cpp b/src/lrn_api.cpp
@@ -56,8 +56,7 @@ extern "C" miopenStatus_t miopenGetLRNDescriptor(const miopenLRNDescriptor_t lrn
                                                  double* lrnBeta,
                                                  double* lrnK)
 {
-
-    MIOPEN_LOG_FUNCTION(lrnDesc, mode, lrnN, lrnAlpha, lrnBeta, lrnK);
+    MIOPEN_LOG_FUNCTION(lrnDesc);
     return miopen::try_([&] {
         *mode     = miopen::deref(lrnDesc).GetMode();
         *lrnN     = miopen::deref(lrnDesc).GetN();
@@ -70,6 +69,7 @@ extern "C" miopenStatus_t miopenGetLRNDescriptor(const miopenLRNDescriptor_t lrn
 extern "C" miopenStatus_t miopenLRNGetWorkSpaceSize(const miopenTensorDescriptor_t yDesc,
                                                     size_t* workSpaceSize)
 {
+    MIOPEN_LOG_FUNCTION(yDesc);
 
     // TODO: Supporting size 4 bytes only
     return miopen::try_([&] {