style(pr66): sweep assert-message periods + comment backticks

Addresses inline review comments on #66 (reviewer: Ziminli) across all
PR-touched files:

- C4: strip trailing periods from assert messages; lowercase the
  sentence-starting word when it is bare English (e.g. "Ascend ..." →
  "ascend ..."), leave backticked identifiers untouched.
- G4: backtick `RmsNorm` in kernel_custom.h header comment; backtick
  `aclnn` / `cos_sin_cache` / `infini.ops.add_rms_norm(...)` in kernel
  comments that were still running raw text.
- C2: rename `aclrtlaunch_add_rms_norm` / `aclrtlaunch_rms_norm`
  forward-decl parameter names from AscendC internals (`x1, x2, y,
  x_out`) to the base-header semantic names (`input, residual, weight,
  out, residual_out`).  The extern "C" symbol is name-blind so the
  AscendC kernel .cpp can keep its local names — the wrapper .h just
  presents the public contract.
- Pre-gathered rotary test: drop the hardcoded
  `implementation_index=(0, 1)` parametrize, let conftest auto-inject
  and skip impl 2 inline (the impl 2 kernel asserts
  `!pre_gathered_`).

Verified locally (`--gpu-id 3/4/5 --local`):
  test_add_rms_norm.py:      108 passed
  test_rms_norm.py:            72 passed
  test_rotary_embedding.py:    88 passed, 16 skipped (expected:
                                          impl 2 + pre_gathered,
                                          impl 0 + non-neox)

Author: zhangyue

src/ascend/add_rms_norm/kernel_custom.h

@@ -22,8 +22,8 @@
 // `ascendc_add_operator()` and cannot be `PascalCase`d.
 // NOLINTNEXTLINE(readability-identifier-naming)
 extern "C" uint32_t aclrtlaunch_add_rms_norm(
-    uint32_t block_dim, void* stream, void* x1, void* x2, void* weight, void* y,
-    void* x_out, int64_t total_rows, int64_t dim_length,
+    uint32_t block_dim, void* stream, void* input, void* residual, void* weight,
+    void* out, void* residual_out, int64_t total_rows, int64_t dim_length,
     int64_t dim_length_align, int64_t former_num, int64_t former_length,
     int64_t tail_length, float eps, int64_t dtype_code);
 
@@ -57,7 +57,7 @@ class Operator<AddRmsNorm, Device::Type::kAscend, 2> : public AddRmsNorm {
     assert((dtype_ == DataType::kFloat16 || dtype_ == DataType::kBFloat16 ||
             dtype_ == DataType::kFloat32) &&
            "`AddRmsNorm` custom kernel: `input` must be `fp16`, `bf16`, or "
-           "`fp32`.");
+           "`fp32`");
 
     // 32-byte alignment on the last dimension — kernel relies on aligned
     // `DataCopyPad` loads/stores.
@@ -67,7 +67,7 @@ class Operator<AddRmsNorm, Device::Type::kAscend, 2> : public AddRmsNorm {
         align_elems;
     assert(static_cast<int64_t>(dim_) == dim_length_align_ &&
            "`AddRmsNorm` custom kernel: last dimension must be 32-byte "
-           "aligned.");
+           "aligned");
 
     total_rows_ =
         static_cast<int64_t>(batch_size_) * static_cast<int64_t>(nhead_);

src/ascend/add_rms_norm/kernel_fused.h

@@ -22,7 +22,7 @@ namespace infini::ops {
 // large tensors where kernel fusion reduces memory traffic.
 //
 // Select via `implementation_index=1` in Python:
-//   infini.ops.add_rms_norm(..., implementation_index=1, stream=s)
+//   `infini.ops.add_rms_norm(..., implementation_index=1, stream=s)`.
 template <>
 class Operator<AddRmsNorm, Device::Type::kAscend, 1> : public AddRmsNorm {
  public:

src/ascend/rms_norm/kernel_custom.h

@@ -23,28 +23,29 @@
 // `ascendc_add_operator()` and cannot be `PascalCase`d.
 // NOLINTNEXTLINE(readability-identifier-naming)
 extern "C" uint32_t aclrtlaunch_rms_norm(
-    uint32_t block_dim, void* stream, void* x, void* weight, void* y,
+    uint32_t block_dim, void* stream, void* input, void* weight, void* out,
     int64_t total_rows, int64_t dim_length, int64_t dim_length_align,
     int64_t former_num, int64_t former_length, int64_t tail_length, float eps,
     int64_t dtype_code);
 
 namespace infini::ops {
 
-// Custom AscendC fused RmsNorm kernel (implementation index 1).
+// Custom AscendC fused `RmsNorm` kernel (implementation index 1).
 //
-// A single-kernel implementation that computes RMSNorm in one launch, avoiding
-// the 5-sub-op decomposition of `aclnnRmsNorm` (index 0).  Uses `Sqrt` +
-// scalar division instead of `Rsqrt` for higher precision (~1e-7 fp32 error
-// vs ~0.2% with `Rsqrt`).
+// A single-kernel implementation that computes `RMSNorm` in one launch,
+// avoiding the 5-sub-op decomposition of `aclnnRmsNorm` (index 0).  Uses
+// `Sqrt` + scalar division instead of `Rsqrt` for higher precision (~1e-7
+// `fp32` error vs ~0.2% with `Rsqrt`).
 //
 // Select via `implementation_index=1` in Python:
-//   infini.ops.rms_norm(input, weight, eps, out, implementation_index=1,
-//                       stream=s)
+//   `infini.ops.rms_norm(input, weight, eps, out, implementation_index=1,
+//                        stream=s)`.
 //
 // Requirements:
-//   - Input last dimension must be 32-byte aligned (divisible by 16 for fp16
-//     or 8 for fp32).  All standard LLM hidden dimensions satisfy this.
-//   - Weight must have the same dtype as input.
+//   - Input last dimension must be 32-byte aligned (divisible by 16 for
+//     `fp16` or 8 for `fp32`).  All standard LLM hidden dimensions satisfy
+//     this.
+//   - `weight` must have the same dtype as `input`.
 //   - The custom kernel binary must be linked (`BUILD_ASCEND_CUSTOM=ON`).
 template <>
 class Operator<RmsNorm, Device::Type::kAscend, 1> : public RmsNorm {
@@ -54,7 +55,7 @@ class Operator<RmsNorm, Device::Type::kAscend, 1> : public RmsNorm {
     assert((dtype_ == DataType::kFloat16 || dtype_ == DataType::kBFloat16 ||
             dtype_ == DataType::kFloat32) &&
            "`RmsNorm` custom kernel: `input` must be `fp16`, `bf16`, or "
-           "`fp32`.");
+           "`fp32`");
 
     // 32-byte alignment on the last dimension — kernel relies on aligned
     // `DataCopyPad` loads/stores.
@@ -63,7 +64,7 @@ class Operator<RmsNorm, Device::Type::kAscend, 1> : public RmsNorm {
         ((static_cast<int64_t>(dim_) + align_elems - 1) / align_elems) *
         align_elems;
     assert(static_cast<int64_t>(dim_) == dim_length_align_ &&
-           "`RmsNorm` custom kernel: last dimension must be 32-byte aligned.");
+           "`RmsNorm` custom kernel: last dimension must be 32-byte aligned");
 
     total_rows_ =
         static_cast<int64_t>(batch_size_) * static_cast<int64_t>(nhead_);

src/ascend/rotary_embedding/kernel.h

@@ -52,15 +52,15 @@ class Operator<RotaryEmbedding, Device::Type::kAscend>
         max_seq_len_{cos_sin_cache.size(0)},
         elem_sz_{cos_sin_cache.element_size()} {
     assert(rotary_dim == head_size &&
-           "Ascend `RotaryEmbedding`: `rotary_dim` must equal `head_size` "
-           "(partial rotation is not implemented in this wrapper).");
+           "ascend `RotaryEmbedding`: `rotary_dim` must equal `head_size` "
+           "(partial rotation is not implemented in this wrapper)");
     assert(is_neox_style &&
-           "Ascend `RotaryEmbedding`: `is_neox_style` must be `true` — "
+           "ascend `RotaryEmbedding`: `is_neox_style` must be `true` — "
            "this wrapper only plumbs `rotaryMode=\"half\"` through "
-           "`aclnnApplyRotaryPosEmbV2`.");
+           "`aclnnApplyRotaryPosEmbV2`");
     assert(has_key_ &&
-           "Ascend `RotaryEmbedding` (impl 0): `key` is required — "
-           "`aclnnApplyRotaryPosEmbV2` always rotates Q and K together.");
+           "ascend `RotaryEmbedding` (impl 0): `key` is required — "
+           "`aclnnApplyRotaryPosEmbV2` always rotates Q and K together");
 
     // Resolve optional out buffers; when omitted, RoPE writes back in place
     // on `query` / `key` — vLLM-style inplace semantics.

src/ascend/rotary_embedding/kernel_atb.h

@@ -56,7 +56,8 @@ namespace infini::ops {
 //       * `rotaryCoeff=2` when `is_neox_style=true`  (half split + cat)
 //       * `rotaryCoeff=head_size` when `is_neox_style=false` (interleave)
 //     Partial rotary (`rotary_dim < head_size`) is not supported by either
-//     the aclnn or ATB fused APIs; callers must pad to `head_size` upstream.
+//     the `aclnn` or ATB fused APIs; callers must pad to `head_size`
+//     upstream.
 template <>
 class Operator<RotaryEmbedding, Device::Type::kAscend, 1>
     : public RotaryEmbedding {
@@ -71,11 +72,11 @@ class Operator<RotaryEmbedding, Device::Type::kAscend, 1>
                         is_neox_style, rotary_dim, query_out, key_out,
                         pre_gathered) {
     assert(rotary_dim == head_size &&
-           "Ascend `RotaryEmbedding` (ATB): `rotary_dim` must equal "
-           "`head_size` — ATB `RopeParam` does not support partial rotary.");
+           "ascend `RotaryEmbedding` (ATB): `rotary_dim` must equal "
+           "`head_size` — ATB `RopeParam` does not support partial rotary");
     assert(has_key_ &&
-           "Ascend `RotaryEmbedding` (ATB): `key` is required — ATB "
-           "`RopeParam` always rotates Q and K together.");
+           "ascend `RotaryEmbedding` (ATB): `key` is required — ATB "
+           "`RopeParam` always rotates Q and K together");
 
     const int64_t head_dim = head_size_;
     const size_t elem_sz = cos_sin_cache.element_size();
@@ -101,7 +102,7 @@ class Operator<RotaryEmbedding, Device::Type::kAscend, 1>
       aclrtMalloc(&cos_table_dev_, table_bytes, ACL_MEM_MALLOC_NORMAL_ONLY);
       aclrtMalloc(&sin_table_dev_, table_bytes, ACL_MEM_MALLOC_NORMAL_ONLY);
 
-      // Upload the initial cos_sin_cache.  `cos_sin_cache_data_` memorizes
+      // Upload the initial `cos_sin_cache`.  `cos_sin_cache_data_` memorizes
       // the source pointer; if the caller later hands in a different buffer,
       // `operator()` re-runs the upload.
       UploadCosSinCache(cos_sin_cache);
@@ -142,7 +143,7 @@ class Operator<RotaryEmbedding, Device::Type::kAscend, 1>
     param.cosFormat = 0;  // Inference mode.
     atb::Status s = atb::CreateOperation(param, &op_);
 
-    assert(s == atb::NO_ERROR && "`atb::CreateOperation(Rope)` failed.");
+    assert(s == atb::NO_ERROR && "`atb::CreateOperation(Rope)` failed");
   }
 
   ~Operator() {
@@ -295,7 +296,7 @@ class Operator<RotaryEmbedding, Device::Type::kAscend, 1>
     uint64_t ws_size = 0;
     atb::Status s = op_->Setup(vp, ws_size, ctx);
 
-    assert(s == atb::NO_ERROR && "ATB Rope `Setup` failed.");
+    assert(s == atb::NO_ERROR && "ATB Rope `Setup` failed");
 
     uint8_t* ws_ptr = nullptr;
 
@@ -306,7 +307,7 @@ class Operator<RotaryEmbedding, Device::Type::kAscend, 1>
 
     s = op_->Execute(vp, ws_ptr, ws_size, ctx);
 
-    assert(s == atb::NO_ERROR && "ATB Rope `Execute` failed.");
+    assert(s == atb::NO_ERROR && "ATB Rope `Execute` failed");
   }
 
  private:

src/ascend/rotary_embedding/kernel_sincos_cache.h

@@ -51,12 +51,12 @@ class Operator<RotaryEmbedding, Device::Type::kAscend, 2>
                         pre_gathered),
         max_seq_len_{cos_sin_cache.size(0)} {
     assert(has_key_ &&
-           "Ascend `RotaryEmbedding` (`aclnnRopeWithSinCosCache`): `key` is "
-           "required — this fused API always rotates Q and K together.");
+           "ascend `RotaryEmbedding` (`aclnnRopeWithSinCosCache`): `key` is "
+           "required — this fused API always rotates Q and K together");
     assert(!pre_gathered_ &&
-           "Ascend `RotaryEmbedding` (`aclnnRopeWithSinCosCache`): "
+           "ascend `RotaryEmbedding` (`aclnnRopeWithSinCosCache`): "
            "`pre_gathered` is not supported — use implementation index 0 or "
-           "1 for the pre-gathered fast path.");
+           "1 for the pre-gathered fast path");
 
     // Resolve optional out buffers (inplace on `query` / `key` when omitted).
     // Non-const so `.data()` returns a writable `void*`.
@@ -143,7 +143,7 @@ class Operator<RotaryEmbedding, Device::Type::kAscend, 2>
     auto ret = aclnnRopeWithSinCosCacheGetWorkspaceSize(
         t_pos, t_q, t_k, t_cache, /*mropeSection=*/nullptr, head_size,
         is_neox_style, t_q_out, t_k_out, &ws_size, &executor);
-    assert(ret == 0 && "`aclnnRopeWithSinCosCacheGetWorkspaceSize` failed.");
+    assert(ret == 0 && "`aclnnRopeWithSinCosCacheGetWorkspaceSize` failed");
 
     void* ws_buf = nullptr;
 
@@ -153,7 +153,7 @@ class Operator<RotaryEmbedding, Device::Type::kAscend, 2>
     }
 
     ret = aclnnRopeWithSinCosCache(ws_buf, ws_size, executor, stream);
-    assert(ret == 0 && "`aclnnRopeWithSinCosCache` failed.");
+    assert(ret == 0 && "`aclnnRopeWithSinCosCache` failed");
   }
 
  private:

src/base/add_rms_norm.h

@@ -22,12 +22,11 @@ class AddRmsNorm : public Operator<AddRmsNorm> {
         batch_size_{ndim_ == 2 ? input.size(-2) : input.size(-3)},
         nhead_{ndim_ == 2 ? 1 : input.size(-2)} {
     assert(input.dtype() == residual.dtype() &&
-           "`AddRmsNorm`: `input` and `residual` must have the same dtype.");
+           "`AddRmsNorm`: `input` and `residual` must have the same dtype");
     assert(input.dtype() == out.dtype() &&
-           "`AddRmsNorm`: `input` and `out` must have the same dtype.");
-    assert(
-        input.dtype() == residual_out.dtype() &&
-        "`AddRmsNorm`: `input` and `residual_out` must have the same dtype.");
+           "`AddRmsNorm`: `input` and `out` must have the same dtype");
+    assert(input.dtype() == residual_out.dtype() &&
+           "`AddRmsNorm`: `input` and `residual_out` must have the same dtype");
   }
 
   AddRmsNorm(Tensor input, Tensor residual, const Tensor weight, float eps)

src/base/linear.h

@@ -41,13 +41,13 @@ class Linear : public Operator<Linear> {
       : Linear{input, weight, bias, /*trans_a=*/false, /*trans_b=*/true, out} {
     assert(weight.ndim() >= 2 &&
            "`Linear`: `weight` must have at least 2 dims "
-           "`[..., out_features, in_features]`.");
+           "`[..., out_features, in_features]`");
     assert(weight.size(-1) == input.size(-1) &&
            "`Linear`: `weight.shape[-1]` must equal `input.shape[-1]` "
-           "(`in_features`).");
+           "(`in_features`)");
     assert(weight.size(-2) == out.size(-1) &&
            "`Linear`: `weight.shape[-2]` must equal `out.shape[-1]` "
-           "(`out_features`).");
+           "(`out_features`)");
   }
 
   // Deprecated — use `(input, weight, bias, out)` overload.

src/base/rotary_embedding.h

@@ -40,25 +40,25 @@ class RotaryEmbedding : public Operator<RotaryEmbedding> {
         has_key_{key.has_value()},
         pre_gathered_{pre_gathered} {
     assert(positions.dtype() == DataType::kInt64 &&
-           "`RotaryEmbedding`: `positions` must be `int64` (vLLM convention).");
+           "`RotaryEmbedding`: `positions` must be `int64` (vLLM convention)");
 
     assert((query.ndim() == 2 || query.ndim() == 3) &&
            "`RotaryEmbedding`: `query` must be 2D `[T, Nq * head_size]` or 3D "
-           "`[T, Nq, head_size]`.");
+           "`[T, Nq, head_size]`");
 
     // TODO: relax once an MLA-capable Ascend impl lands.  The signature keeps
     // `std::optional<Tensor> key` for vLLM-API compatibility, but all current
     // Ascend impls assume `key` is present and rotate Q and K together.
     assert(key.has_value() &&
            "`RotaryEmbedding`: `key` is required; the `key = None` (MLA) path "
-           "is not yet implemented on any backend.");
+           "is not yet implemented on any backend");
 
     assert((key->ndim() == 2 || key->ndim() == 3) &&
            "`RotaryEmbedding`: `key` must be 2D `[T, Nkv * head_size]` or 3D "
-           "`[T, Nkv, head_size]`.");
+           "`[T, Nkv, head_size]`");
 
     assert(rotary_dim <= head_size &&
-           "`RotaryEmbedding`: `rotary_dim` must be `<= head_size`.");
+           "`RotaryEmbedding`: `rotary_dim` must be `<= head_size`");
   }
 
   virtual void operator()(const Tensor positions, const Tensor query,

src/base/silu_and_mul.h

@@ -23,7 +23,7 @@ class SiluAndMul : public Operator<SiluAndMul> {
         is_input_contiguous_{input.IsContiguous()},
         is_out_contiguous_{out.IsContiguous()} {
     assert(input_dtype_ == out_dtype_ &&
-           "`SiluAndMul`: `input` and `out` must have the same dtype.");
+           "`SiluAndMul`: `input` and `out` must have the same dtype");
   }
 
   SiluAndMul(const Tensor input, Tensor out) : SiluAndMul{input, -1, out} {}