remove .hip extension

driver/device_convolution_direct_v2_nchw_kcyx_nkhw.hpp

 #pragma once
 #include <unistd.h>
 #include "device.hpp"
-#include "gridwise_convolution_wrapper.hip.hpp"
-#include "gridwise_convolution_direct_v2_nchw_kcyx_nkhw.hip.hpp"
+#include "gridwise_convolution_wrapper.hpp"
+#include "gridwise_convolution_direct_v2_nchw_kcyx_nkhw.hpp"
 
 template <class T, class InDesc, class WeiDesc, class OutDesc>
 void device_convolution_direct_v2_nchw_kcyx_nkhw(InDesc,

driver/device_convolution_implicit_gemm_v1_chwn_cyxk_khwn.hpp

 #pragma once
 #include <unistd.h>
 #include "device.hpp"
-#include "gridwise_convolution_wrapper.hip.hpp"
-#include "gridwise_convolution_implicit_gemm_v1r1_chwn_cyxk_khwn.hip.hpp"
-#include "gridwise_convolution_implicit_gemm_v1r2_chwn_cyxk_khwn.hip.hpp"
-#include "gridwise_convolution_implicit_gemm_v1r3_chwn_cyxk_khwn.hip.hpp"
-#include "gridwise_convolution_implicit_gemm_v1r3_lds_double_buffer_chwn_cyxk_khwn.hip.hpp"
+#include "gridwise_convolution_wrapper.hpp"
+#include "gridwise_convolution_implicit_gemm_v1r1_chwn_cyxk_khwn.hpp"
+#include "gridwise_convolution_implicit_gemm_v1r2_chwn_cyxk_khwn.hpp"
+#include "gridwise_convolution_implicit_gemm_v1r3_chwn_cyxk_khwn.hpp"
+#include "gridwise_convolution_implicit_gemm_v1r3_lds_double_buffer_chwn_cyxk_khwn.hpp"
 
 template <class T, class InDesc, class WeiDesc, class OutDesc>
 void device_convolution_implicit_gemm_v1_chwn_cyxk_khwn(InDesc,

driver/device_convolution_implicit_gemm_v1_nchw_cyxk_khwn.hpp

 #pragma once
 #include <unistd.h>
 #include "device.hpp"
-#include "gridwise_convolution_wrapper.hip.hpp"
-#include "gridwise_convolution_implicit_gemm_v1r2_nchw_cyxk_khwn.hip.hpp"
-#include "gridwise_convolution_implicit_gemm_v1r3_nchw_cyxk_khwn.hip.hpp"
-#include "gridwise_convolution_implicit_gemm_v1r3_lds_double_buffer_nchw_cyxk_khwn.hip.hpp"
+#include "gridwise_convolution_wrapper.hpp"
+#include "gridwise_convolution_implicit_gemm_v1r2_nchw_cyxk_khwn.hpp"
+#include "gridwise_convolution_implicit_gemm_v1r3_nchw_cyxk_khwn.hpp"
+#include "gridwise_convolution_implicit_gemm_v1r3_lds_double_buffer_nchw_cyxk_khwn.hpp"
 
 template <class T, class InDesc, class WeiDesc, class OutDesc>
 void device_convolution_implicit_gemm_v1_nchw_cyxk_khwn(InDesc,

driver/device_convolution_implicit_gemm_v1_nchw_cyxk_nkhw.hpp

 #pragma once
 #include <unistd.h>
 #include "device.hpp"
-#include "gridwise_convolution_wrapper.hip.hpp"
-#include "gridwise_convolution_implicit_gemm_v1r3_nchw_cyxk_nkhw.hip.hpp"
-#include "gridwise_convolution_implicit_gemm_v1r3_lds_double_buffer_nchw_cyxk_nkhw.hip.hpp"
+#include "gridwise_convolution_wrapper.hpp"
+#include "gridwise_convolution_implicit_gemm_v1r3_nchw_cyxk_nkhw.hpp"
+#include "gridwise_convolution_implicit_gemm_v1r3_lds_double_buffer_nchw_cyxk_nkhw.hpp"
 
 template <class T, class InDesc, class WeiDesc, class OutDesc>
 void device_convolution_implicit_gemm_v1_nchw_cyxk_nkhw(InDesc,

driver/device_convolution_implicit_gemm_v2_chwn_cyxk_khwn.hpp

 #pragma once
 #include <unistd.h>
 #include "device.hpp"
-#include "gridwise_convolution_wrapper.hip.hpp"
-#include "gridwise_convolution_implicit_gemm_v2_chwn_cyxk_khwn.hip.hpp"
-#include "gridwise_convolution_implicit_gemm_v2_chwn_cyxk_khwn_lds_double_buffer.hip.hpp"
+#include "gridwise_convolution_wrapper.hpp"
+#include "gridwise_convolution_implicit_gemm_v2_chwn_cyxk_khwn.hpp"
+#include "gridwise_convolution_implicit_gemm_v2_chwn_cyxk_khwn_lds_double_buffer.hpp"
 
 template <class T, class InDesc, class WeiDesc, class OutDesc>
 void device_convolution_implicit_gemm_v2_chwn_cyxk_khwn(InDesc,

driver/device_convolution_implicit_gemm_v3_nchw_cyxk_nkhw.hpp

 #pragma once
 #include <unistd.h>
 #include "device.hpp"
-#include "gridwise_convolution_wrapper.hip.hpp"
-#include "gridwise_convolution_implicit_gemm_v3_nchw_cyxk_nkhw.hip.hpp"
-#include "gridwise_convolution_implicit_gemm_v3_lds_double_buffer_nchw_cyxk_nkhw.hip.hpp"
+#include "gridwise_convolution_wrapper.hpp"
+#include "gridwise_convolution_implicit_gemm_v3_nchw_cyxk_nkhw.hpp"
+#include "gridwise_convolution_implicit_gemm_v3_lds_double_buffer_nchw_cyxk_nkhw.hpp"
 
 template <class T, class InDesc, class WeiDesc, class OutDesc>
 void device_convolution_implicit_gemm_v3_nchw_cyxk_nkhw(InDesc,

driver/device_convolution_implicit_gemm_v4_nchw_kcyx_nkhw.hpp

 #pragma once
 #include <unistd.h>
 #include "device.hpp"
-#include "gridwise_convolution_wrapper.hip.hpp"
-#include "gridwise_convolution_implicit_gemm_v4_nchw_kcyx_nkhw.hip.hpp"
-#include "gridwise_convolution_implicit_gemm_v4_lds_double_buffer_nchw_kcyx_nkhw.hip.hpp"
+#include "gridwise_convolution_wrapper.hpp"
+#include "gridwise_convolution_implicit_gemm_v4_nchw_kcyx_nkhw.hpp"
+#include "gridwise_convolution_implicit_gemm_v4_lds_double_buffer_nchw_kcyx_nkhw.hpp"
 
 template <class T, class InDesc, class WeiDesc, class OutDesc>
 void device_convolution_implicit_gemm_v4_nchw_kcyx_nkhw(InDesc,

driver/device_direct_convolution_2_vectorized_nchw_kcyx_nkhw.hpp

 #pragma once
 #include <unistd.h>
 #include "device.hpp"
-#include "gridwise_direct_convolution_2_vectorized_nchw_kcyx_nkhw.hip.hpp"
+#include "gridwise_direct_convolution_2_vectorized_nchw_kcyx_nkhw.hpp"
 
 template <class TInWei, class TOut, class InDesc, class WeiDesc, class OutDesc>
 void device_direct_convolution_2_vectorized_nchw_kcyx_nkhw(InDesc,

driver/device_implicit_gemm_convolution_1_chwn_cyxk_khwn_padded.hpp

 #pragma once
 #include <unistd.h>
 #include "device.hpp"
-#include "gridwise_implicit_gemm_convolution_1_chwn_cyxk_khwn_padded.hip.hpp"
+#include "gridwise_implicit_gemm_convolution_1_chwn_cyxk_khwn_padded.hpp"
 
 template <class T, class InDesc, class WeiDesc, class OutDesc, class LowerPads, class UpperPads>
 void device_implicit_gemm_convolution_1_chwn_cyxk_khwn_padded(InDesc,

driver/driver.hip.cpp → driver/driver.cpp

@@ -5,8 +5,8 @@
 #include <stdlib.h>
 #include "config.h"
 #include "tensor.hpp"
-#include "ConstantTensorDescriptor.hip.hpp"
-#include "conv_common.hip.hpp"
+#include "ConstantTensorDescriptor.hpp"
+#include "conv_common.hpp"
 #include "device_convolution_direct_v2_nchw_kcyx_nkhw.hpp"
 //#include "device_direct_convolution_2_vectorized_nchw_kcyx_nkhw.hpp"
 #include "device_convolution_implicit_gemm_v1_chwn_cyxk_khwn.hpp"

driver/driver.cu

-driver.hip.cpp
+driver.cpp
\ No newline at end of file

src/include/Array.hip.hpp → src/include/Array.hpp

 #pragma once
-#include "Sequence.hip.hpp"
-#include "functional2.hip.hpp"
+#include "Sequence.hpp"
+#include "functional2.hpp"
 
 template <class TData, index_t NSize>
 struct Array

src/include/ConstantMatrixDescriptor.hip.hpp → src/include/ConstantMatrixDescriptor.hpp

 #pragma once
-#include "common.hip.hpp"
+#include "common.hpp"
 
 template <index_t NRow_, index_t NCol_, index_t RowStride_>
 struct ConstantMatrixDescriptor

src/include/ConstantMergedTensorDescriptor.hip.hpp → src/include/ConstantMergedTensorDescriptor.hpp

 #pragma once
-#include "common.hip.hpp"
-#include "ConstantTensorDescriptor.hip.hpp"
+#include "common.hpp"
+#include "ConstantTensorDescriptor.hpp"
 
 // OriginalTensorDesc : ConstantTensorDescriptor<...>
 //     it's the tensor whose dimensions are to be merged

src/include/ConstantTensorDescriptor.hip.hpp → src/include/ConstantTensorDescriptor.hpp

 #pragma once
-#include "common.hip.hpp"
+#include "common.hpp"
 
 template <class Lengths>
 __host__ __device__ constexpr auto calculate_tensor_strides_packed(Lengths)

src/include/Sequence.hip.hpp → src/include/Sequence.hpp

 #pragma once
-#include "integral_constant.hip.hpp"
-#include "functional.hip.hpp"
+#include "integral_constant.hpp"
+#include "functional.hpp"
 
 template <class Seq>
 struct is_valid_sequence_map;

src/include/amd_inline_asm.hip.hpp → src/include/amd_inline_asm.hpp

 #pragma once
-#include "common.hip.hpp"
+#include "common.hpp"
 
 #define NO_VM_WAIT 0
 #define NO_LGKM_WAIT 0

src/include/blockwise_2d_tensor_op.hip.hpp → src/include/blockwise_2d_tensor_op.hpp

 #pragma once
-#include "common.hip.hpp"
-#include "ConstantTensorDescriptor.hip.hpp"
+#include "common.hpp"
+#include "ConstantTensorDescriptor.hpp"
 
 template <index_t BlockSize, class Float, class DstDesc, class F>
 __device__ void

src/include/blockwise_3d_tensor_op.hip.hpp → src/include/blockwise_3d_tensor_op.hpp

 #pragma once
-#include "common.hip.hpp"
-#include "ConstantTensorDescriptor.hip.hpp"
+#include "common.hpp"
+#include "ConstantTensorDescriptor.hpp"
 
 template <index_t BlockSize,
           class Float,