Fix compilation errors on HIP and MUSA

Author: gaugarg-nv

ggml/src/ggml-cuda/fattn-vec-f32.cuh

@@ -315,66 +315,68 @@ void ggml_cuda_flash_attn_ext_vec_f32_case(ggml_backend_cuda_context & ctx, ggml
         if (logit_softcap == 0.0f) {
             constexpr bool use_logit_softcap = false;
 
+            // cudaOccupancyMaxActiveBlocksPerMultiprocessor is not supported on HIP platform
+            // so, skipping the occupancy check for HIP platform
+#if !defined(GGML_USE_HIP) && !defined(GGML_USE_MUSA)
             // Determine the number of active blocks per SM
             // parallel_blocks template parameter has no effect on the number of active blocks, so keeping a constant 4 to determine active blocks
             int numActiveBlocks = 1;
-            CUDA_CHECK(cudaOccupancyMaxActiveBlocksPerMultiprocessor(&numActiveBlocks, flash_attn_vec_ext_f32<D, cols_per_block, 4, type_K, type_V, use_logit_softcap>, D, 0));
+            CUDA_CHECK(cudaOccupancyMaxActiveBlocksPerMultiprocessor(&numActiveBlocks, 
+                        flash_attn_vec_ext_f32<D, cols_per_block, 4, type_K, type_V, use_logit_softcap>, D, 0));
 
             // we want to keep at least `numActiveBlocks` blocks per SM to improve occupancy.
             // this kernel operates on `D` tile of seq length. We need to consider how many `D` tiles can be processed in parallel. 
             // If there are not enough tiles to process, we can reduce the number of blocks
             const int parallel_blocks = std::min((nsm * numActiveBlocks) / total_blocks, seqlen_tiles);
 
-            if(parallel_blocks >= 24)
-            {
+            if(parallel_blocks >= 24) {
                 ggml_cuda_flash_attn_ext_vec_f32_case_impl<D, cols_per_block, 24, type_K, type_V, use_logit_softcap>(ctx, dst);
             }
-            else if(parallel_blocks >= 16)
-            {
+            else if(parallel_blocks >= 16) {
                 ggml_cuda_flash_attn_ext_vec_f32_case_impl<D, cols_per_block, 16, type_K, type_V, use_logit_softcap>(ctx, dst);
             }
-            else if(parallel_blocks >= 12)
-            {
+            else if(parallel_blocks >= 12) {
                 ggml_cuda_flash_attn_ext_vec_f32_case_impl<D, cols_per_block, 12, type_K, type_V, use_logit_softcap>(ctx, dst);
             }
-            else if(parallel_blocks >= 8)
-            {
+            else if(parallel_blocks >= 8) {
                 ggml_cuda_flash_attn_ext_vec_f32_case_impl<D, cols_per_block, 8, type_K, type_V, use_logit_softcap>(ctx, dst);
             }
-            else
+            else 
+#endif // !defined(GGML_USE_HIP) && !defined(GGML_USE_MUSA)
             {
                 ggml_cuda_flash_attn_ext_vec_f32_case_impl<D, cols_per_block, 4, type_K, type_V, use_logit_softcap>(ctx, dst);
             }
         }
         else
         {
             constexpr bool use_logit_softcap = true;
+
+#if !defined(GGML_USE_HIP) && !defined(GGML_USE_MUSA)
             int numActiveBlocks = 1;
-            CUDA_CHECK(cudaOccupancyMaxActiveBlocksPerMultiprocessor(&numActiveBlocks, flash_attn_vec_ext_f32<D, cols_per_block, 4, type_K, type_V, use_logit_softcap>, D, 0));
+            CUDA_CHECK(cudaOccupancyMaxActiveBlocksPerMultiprocessor(&numActiveBlocks, 
+                        flash_attn_vec_ext_f32<D, cols_per_block, 4, type_K, type_V, use_logit_softcap>, D, 0));
 
             const int parallel_blocks = std::min((nsm * numActiveBlocks) / total_blocks, seqlen_tiles);
 
-            if(parallel_blocks >= 24)
-            {
+            if(parallel_blocks >= 24) {
                 ggml_cuda_flash_attn_ext_vec_f32_case_impl<D, cols_per_block, 24, type_K, type_V, use_logit_softcap>(ctx, dst);
             }
-            else if(parallel_blocks >= 16)
-            {
+            else if(parallel_blocks >= 16) {
                 ggml_cuda_flash_attn_ext_vec_f32_case_impl<D, cols_per_block, 16, type_K, type_V, use_logit_softcap>(ctx, dst);
             }
-            else if(parallel_blocks >= 12)
-            {
+            else if(parallel_blocks >= 12) {
                 ggml_cuda_flash_attn_ext_vec_f32_case_impl<D, cols_per_block, 12, type_K, type_V, use_logit_softcap>(ctx, dst);
             }
-            else if(parallel_blocks >= 8)
-            {
+            else if(parallel_blocks >= 8) {
                 ggml_cuda_flash_attn_ext_vec_f32_case_impl<D, cols_per_block, 8, type_K, type_V, use_logit_softcap>(ctx, dst);
             }
-            else
+            else 
+#endif // !defined(GGML_USE_HIP) && !defined(GGML_USE_MUSA)
             {
                 ggml_cuda_flash_attn_ext_vec_f32_case_impl<D, cols_per_block, 4, type_K, type_V, use_logit_softcap>(ctx, dst);
             }
         }
+
         return;
     }
 

ggml/src/ggml-cuda/fattn.cu

@@ -244,9 +244,6 @@ static void ggml_cuda_flash_attn_ext_vec_f32(ggml_backend_cuda_context & ctx, gg
 void ggml_cuda_flash_attn_ext(ggml_backend_cuda_context & ctx, ggml_tensor * dst) {
     const ggml_tensor * KQV  = dst;
     const ggml_tensor * Q    = dst->src[0];
-    const ggml_tensor * K    = dst->src[1];
-    const ggml_tensor * V    = dst->src[2];
-    const ggml_tensor * mask = dst->src[3];
 
     ggml_cuda_set_device(ctx.device);
     const int cc = ggml_cuda_info().devices[ggml_cuda_get_device()].cc;
@@ -296,7 +293,6 @@ void ggml_cuda_flash_attn_ext(ggml_backend_cuda_context & ctx, ggml_tensor * dst
         return;
     }
 
-    const int gqa_ratio = Q->ne[2] / K->ne[2];
     if (Q->ne[1] == 1 && Q->ne[0] % (2*WARP_SIZE) == 0) {
         if (prec == GGML_PREC_DEFAULT) {
             ggml_cuda_flash_attn_ext_vec_f16(ctx, dst);