fix: update InfiniRT runtime API usage

src/native/cuda/hygon/runtime_.h

@@ -16,10 +16,14 @@ namespace infini::ops {
 template <>
 struct Runtime<Device::Type::kHygon>
     : CudaRuntime<Runtime<Device::Type::kHygon>> {
+  using Error = cudaError_t;
+
   using Stream = cudaStream_t;
 
   static constexpr Device::Type kDeviceType = Device::Type::kHygon;
 
+  static constexpr Error kSuccess = cudaSuccess;
+
   static constexpr auto Malloc = [](auto&&... args) {
     return cudaMalloc(std::forward<decltype(args)>(args)...);
   };
@@ -30,9 +34,9 @@ struct Runtime<Device::Type::kHygon>
     return cudaFree(std::forward<decltype(args)>(args)...);
   };
 
-  static constexpr auto MemcpyHostToDevice = cudaMemcpyHostToDevice;
+  static constexpr auto kMemcpyHostToDevice = cudaMemcpyHostToDevice;
 
-  static constexpr auto MemcpyDeviceToHost = cudaMemcpyDeviceToHost;
+  static constexpr auto kMemcpyDeviceToHost = cudaMemcpyDeviceToHost;
 
   static constexpr auto Memset = cudaMemset;
 };

src/native/cuda/ops/add/kernel.h

@@ -51,7 +51,7 @@ class CudaAdd : public Add {
     std::memcpy(metadata.data() + offset, out_strides_.data(), strides_size);
 
     Backend::Memcpy(d_metadata_, metadata.data(), metadata_size,
-                    Backend::MemcpyHostToDevice);
+                    Backend::kMemcpyHostToDevice);
   }
 
   ~CudaAdd() { Backend::Free(d_metadata_); }

src/native/cuda/ops/conv_infinilm/kernel.h

@@ -93,7 +93,7 @@ class CudaConvInfinilm : public ConvInfinilm {
     std::memcpy(metadata.data() + offset, dilation_.data(), attrs_size);
 
     Backend::Memcpy(d_metadata_, metadata.data(), metadata_size,
-                    Backend::MemcpyHostToDevice);
+                    Backend::kMemcpyHostToDevice);
   }
 
   ~CudaConvInfinilm() { Backend::Free(d_metadata_); }

src/native/cuda/ops/embedding/kernel.h

@@ -57,7 +57,7 @@ class CudaEmbedding : public Embedding {
                 out_strides_size);
 
     Backend::Memcpy(d_metadata_, metadata.data(), metadata_size,
-                    Backend::MemcpyHostToDevice);
+                    Backend::kMemcpyHostToDevice);
   }
 
   ~CudaEmbedding() { Backend::Free(d_metadata_); }

src/native/cuda/ops/gelu_infinilm/kernel.h

@@ -46,7 +46,7 @@ class CudaGeluInfinilm : public GeluInfinilm {
     std::memcpy(metadata.data() + offset, out_strides_.data(), strides_size);
 
     Backend::Memcpy(d_metadata_, metadata.data(), metadata_size,
-                    Backend::MemcpyHostToDevice);
+                    Backend::kMemcpyHostToDevice);
   }
 
   ~CudaGeluInfinilm() { Backend::Free(d_metadata_); }

src/native/cuda/ops/gelutanh_infinilm/kernel.h

@@ -45,7 +45,7 @@ class CudaGelutanhInfinilm : public GelutanhInfinilm {
     std::memcpy(metadata.data() + offset, out_strides_.data(), strides_size);
 
     Backend::Memcpy(d_metadata_, metadata.data(), metadata_size,
-                    Backend::MemcpyHostToDevice);
+                    Backend::kMemcpyHostToDevice);
   }
 
   ~CudaGelutanhInfinilm() { Backend::Free(d_metadata_); }

src/native/cuda/ops/kv_caching_infinilm/kernel.h

@@ -50,7 +50,7 @@ class CudaKvCachingInfinilm : public KvCachingInfinilm {
     std::memcpy(metadata.data() + offset, v_strides_.data(), strides_size);
 
     Backend::Memcpy(d_metadata_, metadata.data(), metadata_size,
-                    Backend::MemcpyHostToDevice);
+                    Backend::kMemcpyHostToDevice);
   }
 
   ~CudaKvCachingInfinilm() { Backend::Free(d_metadata_); }

src/native/cuda/ops/rearrange_infinilm/kernel.h

@@ -45,7 +45,7 @@ class CudaRearrangeInfinilm : public RearrangeInfinilm {
     std::memcpy(metadata.data() + offset, out_strides_.data(), strides_size);
 
     Backend::Memcpy(d_metadata_, metadata.data(), metadata_size,
-                    Backend::MemcpyHostToDevice);
+                    Backend::kMemcpyHostToDevice);
   }
 
   ~CudaRearrangeInfinilm() { Backend::Free(d_metadata_); }

src/native/cuda/ops/relu_infinilm/kernel.h

@@ -44,7 +44,7 @@ class CudaReluInfinilm : public ReluInfinilm {
     std::memcpy(metadata.data() + offset, out_strides_.data(), strides_size);
 
     Backend::Memcpy(d_metadata_, metadata.data(), metadata_size,
-                    Backend::MemcpyHostToDevice);
+                    Backend::kMemcpyHostToDevice);
   }
 
   ~CudaReluInfinilm() { Backend::Free(d_metadata_); }

src/native/cuda/ops/sigmoid_infinilm/kernel.h

@@ -45,7 +45,7 @@ class CudaSigmoidInfinilm : public SigmoidInfinilm {
     std::memcpy(metadata.data() + offset, out_strides_.data(), strides_size);
 
     Backend::Memcpy(d_metadata_, metadata.data(), metadata_size,
-                    Backend::MemcpyHostToDevice);
+                    Backend::kMemcpyHostToDevice);
   }
 
   ~CudaSigmoidInfinilm() { Backend::Free(d_metadata_); }

src/native/cuda/ops/silu/kernel.h

@@ -44,7 +44,7 @@ class CudaSilu : public Silu {
     std::memcpy(metadata.data() + offset, out_strides_.data(), strides_size);
 
     Backend::Memcpy(d_metadata_, metadata.data(), metadata_size,
-                    Backend::MemcpyHostToDevice);
+                    Backend::kMemcpyHostToDevice);
   }
 
   ~CudaSilu() { Backend::Free(d_metadata_); }

src/native/cuda/ops/softmax_infinilm/kernel.h

@@ -42,7 +42,7 @@ class CudaSoftmaxInfinilm : public SoftmaxInfinilm {
     std::memcpy(metadata.data() + offset, out_strides_.data(), strides_size);
 
     Backend::Memcpy(d_metadata_, metadata.data(), metadata_size,
-                    Backend::MemcpyHostToDevice);
+                    Backend::kMemcpyHostToDevice);
   }
 
   ~CudaSoftmaxInfinilm() { Backend::Free(d_metadata_); }

src/native/cuda/ops/swiglu/kernel.h

@@ -51,7 +51,7 @@ class CudaSwiglu : public Swiglu {
     std::memcpy(metadata.data() + offset, out_strides_.data(), strides_size);
 
     Backend::Memcpy(d_metadata_, metadata.data(), metadata_size,
-                    Backend::MemcpyHostToDevice);
+                    Backend::kMemcpyHostToDevice);
   }
 
   ~CudaSwiglu() { Backend::Free(d_metadata_); }

src/native/cuda/ops/topksoftmax_infinilm/kernel.h

@@ -43,7 +43,7 @@ class CudaTopksoftmaxInfinilm : public TopksoftmaxInfinilm {
                 strides_size);
 
     Backend::Memcpy(d_metadata_, metadata.data(), metadata_size,
-                    Backend::MemcpyHostToDevice);
+                    Backend::kMemcpyHostToDevice);
   }
 
   ~CudaTopksoftmaxInfinilm() { Backend::Free(d_metadata_); }

src/native/cuda/ops/zeros_infinilm/kernel.h

@@ -37,7 +37,7 @@ class CudaZerosInfinilm : public ZerosInfinilm {
     std::memcpy(metadata.data() + offset, out_strides_.data(), strides_size);
 
     Backend::Memcpy(d_metadata_, metadata.data(), metadata_size,
-                    Backend::MemcpyHostToDevice);
+                    Backend::kMemcpyHostToDevice);
   }
 
   ~CudaZerosInfinilm() { Backend::Free(d_metadata_); }

src/native/cuda/runtime_.h

@@ -17,9 +17,9 @@ struct CudaRuntime : DeviceRuntime<Derived> {
     DeviceRuntime<Derived>::Validate();
     static_assert(
         std::is_invocable_v<decltype(Derived::Memcpy), void*, const void*,
-                            size_t, decltype(Derived::MemcpyHostToDevice)>,
+                            size_t, decltype(Derived::kMemcpyHostToDevice)>,
         "`Runtime::Memcpy` must be callable with "
-        "`(void*, const void*, size_t, MemcpyHostToDevice)`.");
+        "`(void*, const void*, size_t, kMemcpyHostToDevice)`.");
     return true;
   }
 };

src/runtime.h

@@ -6,10 +6,10 @@
 namespace infini::ops {
 
 template <Device::Type device_type>
-using Runtime = infini::rt::Runtime<device_type>;
+using Runtime = infini::rt::runtime::Runtime<device_type>;
 
 template <typename Derived>
-using DeviceRuntime = infini::rt::DeviceRuntime<Derived>;
+using DeviceRuntime = infini::rt::runtime::DeviceRuntime<Derived>;
 
 }  // namespace infini::ops