style(ascend): rename free-function helpers from camelCase to PascalCase

Per Google C++ Style Guide §Function Names: ordinary non-accessor
functions are PascalCase. Accessors/mutators (get/set on class members)
are snake_case. These 7 are standalone helpers / converters /
predicates — not member accessors — so they need PascalCase.

  threadLocalAtbContext → ThreadLocalAtbContext
  getAtbContext          → GetAtbContext
  toAtbTensor (×2)       → ToAtbTensor
  isAclRuntimeAlive      → IsAclRuntimeAlive
  buildAclTensor         → BuildAclTensor
  toAclDtype             → ToAclDtype
  isIntegerDtype         → IsIntegerDtype

CANN APIs (`aclrtGetDevice`, `aclCreateTensor`, …), STL/PyTorch interop
methods (`begin`/`end`/`size`/`data`/…), and class accessors
(`get_<field>`/`set_<field>`) are all kept as-is — they either belong
to another vendor or match the "looks like a variable" exception.

Callers on the three category branches (op-simple / op-norm-rope /
op-cache-attn) will pick up the new names automatically on rebase.

Author: zhangyue

src/ascend/atb_common_.h

@@ -23,14 +23,14 @@ namespace infini::ops::ascend {
 // expensive (internal tiling buffer allocation), so we cache one per thread.
 // `SetExecuteStream` is called before every `Execute` to match the caller's
 // stream.
-inline atb::Context*& threadLocalAtbContext() {
+inline atb::Context*& ThreadLocalAtbContext() {
   thread_local atb::Context* ctx = nullptr;
 
   return ctx;
 }
 
-inline atb::Context* getAtbContext(aclrtStream stream) {
-  auto*& ctx = threadLocalAtbContext();
+inline atb::Context* GetAtbContext(aclrtStream stream) {
+  auto*& ctx = ThreadLocalAtbContext();
 
   if (!ctx) {
     atb::Status s = atb::CreateContext(&ctx);
@@ -48,9 +48,9 @@ inline atb::Context* getAtbContext(aclrtStream stream) {
 // Sets dtype, ND format, shape dimensions, and the device data pointer.
 // The caller must keep the InfiniOps Tensor alive for the duration of the
 // ATB operation.
-inline atb::Tensor toAtbTensor(const Tensor& t) {
+inline atb::Tensor ToAtbTensor(const Tensor& t) {
   atb::Tensor out;
-  out.desc.dtype = toAclDtype(t.dtype());
+  out.desc.dtype = ToAclDtype(t.dtype());
   out.desc.format = ACL_FORMAT_ND;
   out.desc.shape.dimNum = t.ndim();
   assert(t.ndim() <= atb::MAX_DIM);
@@ -69,7 +69,7 @@ inline atb::Tensor toAtbTensor(const Tensor& t) {
 //
 // Useful for sub-views of a larger buffer (e.g. K-cache and V-cache halves
 // of a fused KV cache tensor).
-inline atb::Tensor toAtbTensor(const std::vector<int64_t>& shape,
+inline atb::Tensor ToAtbTensor(const std::vector<int64_t>& shape,
                                aclDataType dtype, void* data,
                                uint64_t data_size) {
   atb::Tensor out;

src/ascend/common.h

@@ -17,7 +17,7 @@ namespace infini::ops::ascend {
 // static destructors run.  Calling `aclrtGetDevice` is the cheapest
 // probe — it fails once the runtime is gone.  Destructors that call
 // ACL/ATB APIs must guard with this to avoid use-after-finalize crashes.
-inline bool isAclRuntimeAlive() {
+inline bool IsAclRuntimeAlive() {
   int32_t dev_id = -1;
 
   return aclrtGetDevice(&dev_id) == ACL_SUCCESS;
@@ -28,7 +28,7 @@ inline bool isAclRuntimeAlive() {
 // When `transpose_last2` is true the last two dimensions are swapped in the
 // descriptor (shape and strides) without copying data.  This is used by GEMM
 // and Matmul to express a transpose via the view.
-inline aclTensor* buildAclTensor(const Tensor& t,
+inline aclTensor* BuildAclTensor(const Tensor& t,
                                  bool transpose_last2 = false) {
   std::vector<int64_t> shape(t.shape().begin(), t.shape().end());
   std::vector<int64_t> strides(t.strides().begin(), t.strides().end());
@@ -57,7 +57,7 @@ inline aclTensor* buildAclTensor(const Tensor& t,
   std::vector<int64_t> storage_shape = {storage_elems};
 
   return aclCreateTensor(
-      shape.data(), static_cast<int64_t>(shape.size()), toAclDtype(t.dtype()),
+      shape.data(), static_cast<int64_t>(shape.size()), ToAclDtype(t.dtype()),
       strides.data(),
       /*storageOffset=*/0, ACL_FORMAT_ND, storage_shape.data(),
       static_cast<int64_t>(storage_shape.size()), const_cast<void*>(t.data()));
@@ -95,7 +95,7 @@ class AclTensorCache {
   }
 
   explicit AclTensorCache(const Tensor& t, bool transpose_last2 = false)
-      : dtype_{toAclDtype(t.dtype())} {
+      : dtype_{ToAclDtype(t.dtype())} {
     shape_.assign(t.shape().begin(), t.shape().end());
     strides_.assign(t.strides().begin(), t.strides().end());
 
@@ -119,7 +119,7 @@ class AclTensorCache {
   }
 
   ~AclTensorCache() {
-    if (tensor_ && isAclRuntimeAlive()) {
+    if (tensor_ && IsAclRuntimeAlive()) {
       aclDestroyTensor(tensor_);
     }
   }
@@ -158,7 +158,7 @@ class AclTensorCache {
   // referenced by a Repeatable `aclOpExecutor` which would be destroyed
   // alongside the tensor, and per CANN 8.5 docs that destruction is our
   // responsibility.  In practice `aclDestroyAclOpExecutor` during process
-  // shutdown crashes even with `isAclRuntimeAlive()` true — see `64c367c` —
+  // shutdown crashes even with `IsAclRuntimeAlive()` true — see `64c367c` —
   // so operators leak the executor at shutdown; skipping `aclDestroyTensor`
   // here keeps `~AclTensorCache` from double-freeing a descriptor the
   // executor still holds.

src/ascend/data_type_.h

@@ -9,7 +9,7 @@
 
 namespace infini::ops::ascend {
 
-inline aclDataType toAclDtype(DataType dt) {
+inline aclDataType ToAclDtype(DataType dt) {
   switch (dt) {
     case DataType::kFloat16:
       return ACL_FLOAT16;
@@ -40,7 +40,7 @@ inline aclDataType toAclDtype(DataType dt) {
 }
 
 // Returns true for integer (signed or unsigned) DataType values.
-inline bool isIntegerDtype(DataType dt) {
+inline bool IsIntegerDtype(DataType dt) {
   switch (dt) {
     case DataType::kInt8:
     case DataType::kInt16:

src/ascend/gemm/kernel.h

@@ -36,10 +36,10 @@ class Operator<Gemm, Device::Type::kAscend> : public Gemm {
                   std::optional<int> trans_b, Tensor c) const override {
     auto stream = static_cast<aclrtStream>(stream_);
 
-    auto t_self = ascend::buildAclTensor(c);
-    auto t_a = ascend::buildAclTensor(a, trans_a_);
-    auto t_b = ascend::buildAclTensor(b, trans_b_);
-    auto t_out = ascend::buildAclTensor(c);
+    auto t_self = ascend::BuildAclTensor(c);
+    auto t_a = ascend::BuildAclTensor(a, trans_a_);
+    auto t_b = ascend::BuildAclTensor(b, trans_b_);
+    auto t_out = ascend::BuildAclTensor(c);
 
     uint64_t ws_needed = 0;
     aclOpExecutor* executor = nullptr;