Re-enable CONV test

Author: RodrigoHolztrattner-QuIC

samples/cooperative_matrix/code/main/cooperative_matrix_shaders.hpp

@@ -264,9 +264,6 @@ layout(local_size_x_id = 0, local_size_y_id = 1, local_size_z_id = 2) in;
 
 void main()
 {
-    if(gl_LocalInvocationIndex == 0)
-       debugPrintfEXT("\nRunning SPIR-V shader (QCOM version) gl_WorkGroupSize(%d, %d, %d)\n", gl_WorkGroupSize.x, gl_WorkGroupSize.y, gl_WorkGroupSize.z);
-
     const uint32_t block_id_m = gl_GlobalInvocationID.y;
     const uint32_t block_id_n = gl_GlobalInvocationID.z;
     if ((block_id_m >= TOTAL_M/TILE_M) || (block_id_n >= TOTAL_N/TILE_N)) return;
@@ -287,15 +284,13 @@ void main()
         uint32_t subMatrixBStartInElements = layoutB_Kfirst ? col * strideBinElements + step : col + step * strideBinElements;
 
         coopmat<A_TYPE, gl_ScopeSubgroup, TILE_M, TILE_K, gl_MatrixUseA> matA;
-#define NEW
-#ifdef NEW
+
         uint32_t uvecA[8];
         for (int i=0; i<8; i++)
-          uvecA[i] = floatBitsToInt(inputA.x[subMatrixAStartInElements + gl_GlobalInvocationID.x * strideAinElements + i]);
-        matA = constructCoopMatA64QCOM(uvecA, gl_Float32QCOM);
-#else
-        coopMatLoad(matA, inputA.x, subMatrixAStartInElements, strideAinElements, int(layoutA_Mfirst));
-#endif
+            uvecA[i] = floatBitsToInt(inputA.x[subMatrixAStartInElements + gl_GlobalInvocationID.x * strideAinElements + i]);
+
+        // convert A vector to A matrix
+        vectorToCoopmatQCOM(uvecA, matA);
 
         coopmat<A_TYPE, gl_ScopeSubgroup, TILE_K, TILE_N, gl_MatrixUseB> matB;
         coopMatLoad(matB, inputB.x, subMatrixBStartInElements, strideBinElements, int(layoutB_Kfirst));

samples/cooperative_matrix/code/main/cooperative_matrix_tester.cpp

@@ -642,23 +642,6 @@ void CooperativeMatrixRunner::RenderUI()
     {
         ImGui::DragInt("Test Repeats", &m_test_repeats, 1.0f, 0, 100);
 
-        // NOTE: Validation (and its transpose option) will be added in a future path
-        ImGui::BeginDisabled();
-        if (m_validate_matrix_result)
-        {
-            ImGui::BeginDisabled();
-            static bool always_true = true;
-            ImGui::Checkbox("Transpose When Needed", &always_true);
-            ImGui::EndDisabled();
-        }
-        else
-        {
-            ImGui::Checkbox("Transpose When Needed", &m_transpose_when_needed);
-        }
-
-        ImGui::Checkbox("Validate Result", &m_validate_matrix_result);
-        ImGui::EndDisabled();
-
         static const char* test_case_names[] = {
             "MxM Basic",
             "MxM Vector To Matrix",
@@ -668,31 +651,36 @@ void CooperativeMatrixRunner::RenderUI()
         int test_type_current_index = static_cast<int>(m_test_type);
         bool changed = false;
 
+        ImGui::Text("Note: Not all tests are compatible with all devices!");
+        ImGui::Text("Check shader instruction set for compatibility if testing other than MXM_BASIC");
+
         if (ImGui::BeginCombo("Test Case", test_case_names[test_type_current_index]))
         {
             // NOTE: Temporarily disabled other tests, new test template coming on the next patch
             for (int i = 0; i < static_cast<int>(TestType::TT_COUNT); ++i)
             {
-                // NOTE: Temporarily disabled other tests, new test template coming on the next patch
-                ImGui::BeginDisabled(i > 0);
-
                 const bool is_selected = (test_type_current_index == i);
                 if (ImGui::Selectable(test_case_names[i], is_selected))
                 {
                     m_test_type = static_cast<TestType>(i);
                     changed     = true;
                 }
 
-                ImGui::EndDisabled();
-
                 if (is_selected)
                     ImGui::SetItemDefaultFocus();
             }
             ImGui::EndCombo();
         }
 
-        ImGui::Separator();
+        ImGui::BeginDisabled(m_test_type != TestType::TT_CONV);
+        ImGui::DragInt("Conv Width", &m_input_width, 1.0f, 1, 256);
+        ImGui::DragInt("Conv Height", &m_input_height, 1.0f, 1, 256);
+        ImGui::Checkbox("Normalize Inputs", &m_normalize_inputs);
+        ImGui::EndDisabled();
+    }
 
+    if (ImGui::CollapsingHeader("Matrix Configuration", ImGuiTreeNodeFlags_None))
+    {
         static const char* fill_type_labels[] = {
                 "Fill with Zero",
                 "Fill with Constants",
@@ -728,6 +716,23 @@ void CooperativeMatrixRunner::RenderUI()
                 m_matrix_transpose_options[i] = static_cast<MatrixTransposeOption>(current_index);
             }
         }
+
+        // NOTE: Validation (and its transpose option) will be added in a future path
+        ImGui::BeginDisabled();
+        if (m_validate_matrix_result)
+        {
+            ImGui::BeginDisabled();
+            static bool always_true = true;
+            ImGui::Checkbox("Transpose When Needed", &always_true);
+            ImGui::EndDisabled();
+        }
+        else
+        {
+            ImGui::Checkbox("Transpose When Needed", &m_transpose_when_needed);
+        }
+
+        ImGui::Checkbox("Validate Result", &m_validate_matrix_result);
+        ImGui::EndDisabled();
     }
 
     if (ImGui::CollapsingHeader("Device Configuration", 0))
@@ -746,8 +751,6 @@ void CooperativeMatrixRunner::RenderUI()
         PrepareTestSession();
     }
 
-    ImGui::Text("For accurate values, make sure you are using the right device configurations (check 'Device Configuration' tab)");
-
     if (m_is_processing_tests)
     {
         ImGui::SameLine();
@@ -758,6 +761,8 @@ void CooperativeMatrixRunner::RenderUI()
         ImGui::BeginDisabled(disable_ui);
     }
 
+    ImGui::Text("For accurate values, make sure you are using the right device configurations (check 'Device Configuration' tab)");
+
     if (!m_test_groups.empty())
     {
         for (int i=0; i< m_test_groups.size(); i++)
@@ -864,6 +869,10 @@ void CooperativeMatrixRunner::RenderUI()
 
                                 ImGui::Text("[Time]: %.2fus", test_result.time_total);
                                 ImGui::Text("[TOPS]: %.2f", test_result.TOPS);
+
+                                if (m_test_type == TT_CONV)
+                                    ImGui::TextDisabled("WxH = %dx%d", test_description.inputWidth, test_description.inputHeight);
+
                                 ImVec4 color = GetPercentageColor(test_result.percentage / 100.0f);
                                 ImGui::PushStyleColor(ImGuiCol_Text, color);
                                 ImGui::Text("[%%]: %.2f", test_result.percentage);
@@ -957,8 +966,8 @@ void CooperativeMatrixRunner::PrepareTestSession()
         new_test_description.gpu_freq_MHz   = m_gpu_freq_MHz;
         new_test_description.test_type      = m_test_type;
 
-        new_test_description.inputWidth  = 8;
-        new_test_description.inputHeight = 8;
+        new_test_description.inputWidth  = m_input_width;
+        new_test_description.inputHeight = m_input_height;
 
         new_test_description.input_type  = test_template_description.input_type;
         new_test_description.output_type = test_template_description.output_type;
@@ -1132,6 +1141,27 @@ std::optional<CooperativeMatrixRunner::TestResult> CooperativeMatrixRunner::RunT
         return std::nullopt;
     }
 
+    if (m_normalize_inputs)
+    {
+        int required_area = MSizeInBlocks * cooperativeMatrixProps.MSize;
+
+        // Start with inputWidth as-is, compute height to match required_area
+        if (inputWidth <= 0) inputWidth = 1; // safety
+        inputHeight = required_area / inputWidth;
+
+        // If division leaves remainder, just force height to match
+        if (inputWidth * inputHeight != required_area)
+        {
+            inputHeight = required_area / inputWidth;
+            if (inputWidth * inputHeight != required_area)
+            {
+                // Last resort: set width = required_area, height = 1
+                inputWidth = required_area;
+                inputHeight = 1;
+            }
+        }
+    }
+
     // Set local_size (workgroup size) based on GPU/Tier, and datatype (fp32, fp16, etc)
     // Default for 'unknown' or gpu/tier not recohgnized is local_size(64,2,2) for all datatyes
     uint32_t local_size_x = 0, local_size_y = 0, local_size_z = 0;

samples/cooperative_matrix/code/main/cooperative_matrix_tester.hpp

@@ -58,8 +58,8 @@ class CooperativeMatrixRunner
         bool layoutC_Mfirst = false;
         bool layoutR_Mfirst = false;
 
-        int inputWidth = 1;
-        int inputHeight = 1;
+        int inputWidth = 32;
+        int inputHeight = 16;
     };
 
     struct TestResult
@@ -140,6 +140,10 @@ class CooperativeMatrixRunner
     bool m_transpose_when_needed = false;
     bool m_validate_matrix_result = false;
 
+    bool m_normalize_inputs = true;
+    int m_input_width = 32;
+    int m_input_height = 16;
+
     bool     m_is_processing_tests   = false;
     uint32_t m_total_tests           = 0;
     uint32_t m_total_processed_tests = 0;