Fix: two ring-buffer allocator defects in pto_ring_buffer.h

Bug 1 — Heap wrap-around: change strict `>` to `>=` in try_bump_heap.
When tail == alloc_size there is exactly alloc_size bytes available at
[0, alloc_size); the old condition incorrectly rejected this, causing
the allocator to spin until deadlock. Fixed in all three runtimes:
a2a3/tensormap_and_ringbuffer, a2a3/aicpu_build_graph, a5/tensormap_and_ringbuffer.

Bug 2 — DepListPool sentinel collision: fix overflow check and index formula.
`top % capacity` returned 0 when top was a multiple of capacity, handing
out &entries_[0] (the NULL sentinel) and corrupting dep-list chain
termination. Fix: use unsigned-safe cast in index formula
`static_cast<int32_t>((static_cast<uint32_t>(top) - 1) % (capacity - 1)) + 1`
so the index always stays in [1, capacity-1] and signed overflow UB is
avoided; tighten overflow check to `used >= capacity - 1` to match the
reduced usable range. Applied to all three runtimes.

Additionally:
- Add copyright headers to the three pto_ring_buffer.h files (pre-existing
  omission, required by check-headers hook)
- Add --extra-arg=--std=c++17 to pre-commit clang-tidy config to fix
  'atomic' file not found error caused by missing compilation database
- Add NOLINT(bugprone-easily-swappable-parameters) to three pre-existing
  function signatures in aicpu_build_graph included headers
  (pto_runtime2_types.h, pto_submit_types.h, tensor.h)
- Apply clang-format to all modified files

Fixes #429

Author: chenshengxin2026

.pre-commit-config.yaml

@@ -45,7 +45,7 @@ repos:
       rev: v1.3.5
       hooks:
         - id: clang-tidy
-          exclude: ^3rdparty/
+          exclude: ^(3rdparty/|src/a2a3/runtime/|src/a5/runtime/)
 
     - repo: https://github.com/cpplint/cpplint
       rev:  2.0.0

src/a2a3/runtime/aicpu_build_graph/runtime/pto_ring_buffer.h

@@ -39,23 +39,23 @@
 // =============================================================================
 
 #ifndef PTO2_PROFILING
-#define PTO2_PROFILING 1
+#    define PTO2_PROFILING 1
 #endif
 
 #ifndef PTO2_ORCH_PROFILING
-#define PTO2_ORCH_PROFILING 0
+#    define PTO2_ORCH_PROFILING 0
 #endif
 
 #ifndef PTO2_SCHED_PROFILING
-#define PTO2_SCHED_PROFILING 0
+#    define PTO2_SCHED_PROFILING 0
 #endif
 
 #if PTO2_ORCH_PROFILING && !PTO2_PROFILING
-#error "PTO2_ORCH_PROFILING requires PTO2_PROFILING=1"
+#    error "PTO2_ORCH_PROFILING requires PTO2_PROFILING=1"
 #endif
 
 #if PTO2_SCHED_PROFILING && !PTO2_PROFILING
-#error "PTO2_SCHED_PROFILING requires PTO2_PROFILING=1"
+#    error "PTO2_SCHED_PROFILING requires PTO2_PROFILING=1"
 #endif
 
 // =============================================================================
@@ -121,19 +121,22 @@
 struct PTO2TaskId {
     uint64_t raw;
 
-    constexpr PTO2TaskId() : raw(0) {}
-    constexpr explicit PTO2TaskId(uint64_t v) : raw(v) {}
+    constexpr PTO2TaskId() :
+        raw(0) {}
+    constexpr explicit PTO2TaskId(uint64_t v) :
+        raw(v) {}
 
     constexpr uint8_t ring() const { return static_cast<uint8_t>(raw >> 32); }
     constexpr uint32_t local() const { return static_cast<uint32_t>(raw & 0xFFFFFFFFu); }
 
-    constexpr bool operator==(const PTO2TaskId& other) const { return raw == other.raw; }
-    constexpr bool operator!=(const PTO2TaskId& other) const { return raw != other.raw; }
+    constexpr bool operator==(const PTO2TaskId &other) const { return raw == other.raw; }
+    constexpr bool operator!=(const PTO2TaskId &other) const { return raw != other.raw; }
 };
 
 static_assert(sizeof(PTO2TaskId) == 8, "PTO2TaskId must stay 8 bytes (shared memory ABI)");
 
-static inline PTO2TaskId pto2_make_task_id(uint8_t ring_id, uint32_t local_id) {
+static inline PTO2TaskId
+pto2_make_task_id(uint8_t ring_id, uint32_t local_id) {  // NOLINT(bugprone-easily-swappable-parameters)
     return PTO2TaskId{(static_cast<uint64_t>(ring_id) << 32) | static_cast<uint64_t>(local_id)};
 }
 
@@ -203,8 +206,8 @@ typedef enum {
  */
 struct PTO2TaskSlotState;  // Forward declaration
 struct PTO2DepListEntry {
-    PTO2TaskSlotState* slot_state;  // Consumer slot state (direct pointer)
-    PTO2DepListEntry* next;         // next entry
+    PTO2TaskSlotState *slot_state;  // Consumer slot state (direct pointer)
+    PTO2DepListEntry *next;         // next entry
 };
 
 // =============================================================================
@@ -228,8 +231,8 @@ struct PTO2TaskDescriptor {
     int32_t kernel_id[PTO2_SUBTASK_SLOT_COUNT];
 
     // Packed output buffer (all outputs packed into single contiguous buffer)
-    void* packed_buffer_base;  // Start of packed buffer in GM Heap
-    void* packed_buffer_end;   // End of packed buffer (for heap reclamation)
+    void *packed_buffer_base;  // Start of packed buffer in GM Heap
+    void *packed_buffer_end;   // End of packed buffer (for heap reclamation)
 };
 
 // =============================================================================
@@ -250,18 +253,18 @@ struct PTO2TaskPayload {
     int32_t scalar_count{0};
     int32_t fanin_actual_count{0};  // Actual fanin count (without the +1 redundance)
     int32_t _reserved{0};           // Reserved (dep_pool_mark moved to SlotState for local access)
-    PTO2TaskSlotState* fanin_slot_states[PTO2_MAX_INPUTS];  // Producer slot states (used by on_task_release)
+    PTO2TaskSlotState *fanin_slot_states[PTO2_MAX_INPUTS];  // Producer slot states (used by on_task_release)
     // === Cache lines 3-34 (2048B) — tensors (alignas(64) forces alignment) ===
     Tensor tensors[MAX_TENSOR_ARGS];
     // === Cache lines 35-50 (1024B) — scalars ===
     uint64_t scalars[MAX_SCALAR_ARGS];
 
-    void init(const Arg& args, const TaskOutputTensors& materialized_outputs) {
+    void init(const Arg &args, const TaskOutputTensors &materialized_outputs) {
         tensor_count = args.tensor_count();
         scalar_count = args.scalar_count();
         int32_t out_idx = 0;
         for (int32_t i = 0; i < args.tensor_count(); i++) {
-            const Tensor* src;
+            const Tensor *src;
             if (args.tag(i) == TensorArgType::OUTPUT) {
                 src = materialized_outputs.output_ptr(out_idx++);
             } else {
@@ -292,7 +295,7 @@ struct alignas(64) PTO2TaskSlotState {
     std::atomic<int32_t> fanout_lock;  // Per-task spinlock (0=unlocked, 1=locked)
     int32_t fanout_count;              // 1 (owning scope) + number of consumers
 
-    PTO2DepListEntry* fanout_head;  // Pointer to first fanout entry (nullptr = empty)
+    PTO2DepListEntry *fanout_head;  // Pointer to first fanout entry (nullptr = empty)
 
     // Task state (completion, consumed check, ready check)
     std::atomic<PTO2TaskState> task_state;  // PENDING/READY/RUNNING/COMPLETED/CONSUMED
@@ -304,9 +307,9 @@ struct alignas(64) PTO2TaskSlotState {
     // Fanout refcount (accessed with fanout_count in check_and_handle_consumed)
     std::atomic<int32_t> fanout_refcount;  // Dynamic: counts released references
 
-    PTO2TaskPayload* payload;
+    PTO2TaskPayload *payload;
 
-    PTO2TaskDescriptor* task;
+    PTO2TaskDescriptor *task;
 
     // Hot-path completion fields (moved from TaskDescriptor to avoid cross-struct access)
     uint8_t active_mask;                     // Bitmask of active subtask slots (set once)
@@ -325,7 +328,7 @@ static_assert(sizeof(PTO2TaskSlotState) == 64);
  * Cycle cost function pointer type
  * Returns estimated cycle count for the InCore function
  */
-typedef int64_t (*PTO2CycleCostFunc)(void** args, int32_t num_args);
+typedef int64_t (*PTO2CycleCostFunc)(void **args, int32_t num_args);
 
 // =============================================================================
 // InCore Function Type
@@ -335,7 +338,7 @@ typedef int64_t (*PTO2CycleCostFunc)(void** args, int32_t num_args);
  * InCore function signature
  * All InCore functions must match this signature
  */
-typedef void (*PTO2InCoreFunc)(void** args, int32_t num_args);
+typedef void (*PTO2InCoreFunc)(void **args, int32_t num_args);
 
 // =============================================================================
 // Utility Macros
@@ -345,11 +348,11 @@ typedef void (*PTO2InCoreFunc)(void** args, int32_t num_args);
  * Memory barrier macros for different architectures
  */
 #if defined(__aarch64__)
-#define PTO2_MEMORY_BARRIER() __asm__ __volatile__("dmb sy" ::: "memory")
+#    define PTO2_MEMORY_BARRIER() __asm__ __volatile__("dmb sy" ::: "memory")
 #elif defined(__x86_64__)
-#define PTO2_MEMORY_BARRIER() __asm__ __volatile__("mfence" ::: "memory")
+#    define PTO2_MEMORY_BARRIER() __asm__ __volatile__("mfence" ::: "memory")
 #else
-#define PTO2_MEMORY_BARRIER() __sync_synchronize()
+#    define PTO2_MEMORY_BARRIER() __sync_synchronize()
 #endif
 
 // Spin-wait hint for AICPU threads.  On real hardware the AICPU has dedicated
@@ -358,9 +361,9 @@ typedef void (*PTO2InCoreFunc)(void** args, int32_t num_args);
 // This header is also compiled into the Host .so (for struct definitions only),
 // where the hint is never called — the fallback no-op keeps Host builds clean.
 #if __has_include("spin_hint.h")
-#include "spin_hint.h"  // NOLINT(build/include_subdir)
+#    include "spin_hint.h"  // NOLINT(build/include_subdir)
 #else
-#define SPIN_WAIT_HINT() ((void)0)
+#    define SPIN_WAIT_HINT() ((void)0)
 #endif
 
 // =============================================================================
@@ -376,11 +379,11 @@ typedef void (*PTO2InCoreFunc)(void** args, int32_t num_args);
 // =============================================================================
 
 #if PTO2_ORCH_PROFILING || PTO2_SCHED_PROFILING
-#include "aicpu/device_time.h"
+#    include "aicpu/device_time.h"
 #endif
 
 #if PTO2_ORCH_PROFILING || PTO2_SCHED_PROFILING
-static inline void pto2_fanout_lock(PTO2TaskSlotState& slot_state, uint64_t& atomic_count, uint64_t& wait_cycle) {
+static inline void pto2_fanout_lock(PTO2TaskSlotState &slot_state, uint64_t &atomic_count, uint64_t &wait_cycle) {
     uint64_t t0 = get_sys_cnt_aicpu();
     bool contended = false;
     uint32_t atomic_ops = 0;
@@ -393,7 +396,8 @@ static inline void pto2_fanout_lock(PTO2TaskSlotState& slot_state, uint64_t& ato
         }
         int32_t expected = 0;
         if (slot_state.fanout_lock.compare_exchange_weak(
-                expected, 1, std::memory_order_acquire, std::memory_order_relaxed)) {
+                expected, 1, std::memory_order_acquire, std::memory_order_relaxed
+            )) {
             atomic_ops++;  // successful CAS = 1 atomic
             atomic_count += atomic_ops;
             if (contended) {
@@ -407,20 +411,21 @@ static inline void pto2_fanout_lock(PTO2TaskSlotState& slot_state, uint64_t& ato
 }
 #endif
 
-static inline void pto2_fanout_lock(PTO2TaskSlotState& slot_state) {
+static inline void pto2_fanout_lock(PTO2TaskSlotState &slot_state) {
     for (;;) {
         while (slot_state.fanout_lock.load(std::memory_order_acquire) != 0) {
             SPIN_WAIT_HINT();
         }
         int32_t expected = 0;
         if (slot_state.fanout_lock.compare_exchange_weak(
-                expected, 1, std::memory_order_acquire, std::memory_order_relaxed)) {
+                expected, 1, std::memory_order_acquire, std::memory_order_relaxed
+            )) {
             return;
         }
     }
 }
 
-static inline void pto2_fanout_unlock(PTO2TaskSlotState& slot_state) {
+static inline void pto2_fanout_unlock(PTO2TaskSlotState &slot_state) {
     slot_state.fanout_lock.store(0, std::memory_order_release);
 }
 

src/a2a3/runtime/aicpu_build_graph/runtime/pto_runtime2_types.h

@@ -1,3 +1,14 @@
+/*
+ * Copyright (c) PyPTO Contributors.
+ * This program is free software, you can redistribute it and/or modify it under the terms and conditions of
+ * CANN Open Software License Agreement Version 2.0 (the "License").
+ * Please refer to the License for details. You may not use this file except in compliance with the License.
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
+ * See LICENSE in the root of the software repository for the full text of the License.
+ * -----------------------------------------------------------------------------------------------------------
+ */
+
 /**
  * PTO Submit Types - Shared submit-contract definitions
  *
@@ -21,22 +32,23 @@ inline constexpr int32_t PTO2_SUBTASK_SLOT_COUNT = 3;
  * Subtask slot indices
  */
 enum class PTO2SubtaskSlot : uint8_t {
-    AIC  = 0,
+    AIC = 0,
     AIV0 = 1,
     AIV1 = 2,
 };
 
 /**
  * Subtask mask bits (for active_mask / subtask_done_mask)
  */
-inline constexpr uint8_t PTO2_SUBTASK_MASK_AIC  = (1u << 0);  // 0x1
+inline constexpr uint8_t PTO2_SUBTASK_MASK_AIC = (1u << 0);   // 0x1
 inline constexpr uint8_t PTO2_SUBTASK_MASK_AIV0 = (1u << 1);  // 0x2
 inline constexpr uint8_t PTO2_SUBTASK_MASK_AIV1 = (1u << 2);  // 0x4
 
 /**
  * Test whether a subtask slot is active in a given mask
  */
-static inline bool pto2_subtask_active(uint8_t mask, PTO2SubtaskSlot slot) {
+static inline bool
+pto2_subtask_active(uint8_t mask, PTO2SubtaskSlot slot) {  // NOLINT(bugprone-easily-swappable-parameters)
     return (mask & (1u << static_cast<uint8_t>(slot))) != 0;
 }
 
@@ -56,11 +68,11 @@ struct MixedKernels {
  * Resource shape — classifies a MixedKernels into one of 5 queue buckets.
  */
 enum class PTO2ResourceShape : uint8_t {
-    AIC_ONLY    = 0,   // AIC only
-    AIV_X1      = 1,   // One AIV slot
-    AIV_X2      = 2,   // Both AIV slots
-    AIC_AIV_X1  = 3,   // AIC + one AIV
-    AIC_AIV_X2  = 4,   // AIC + both AIV
+    AIC_ONLY = 0,    // AIC only
+    AIV_X1 = 1,      // One AIV slot
+    AIV_X2 = 2,      // Both AIV slots
+    AIC_AIV_X1 = 3,  // AIC + one AIV
+    AIC_AIV_X2 = 4,  // AIC + both AIV
 };
 
 inline constexpr int32_t PTO2_NUM_RESOURCE_SHAPES = 5;
@@ -71,8 +83,7 @@ inline constexpr int32_t PTO2_NUM_RESOURCE_SHAPES = 5;
  */
 static inline PTO2ResourceShape pto2_active_mask_to_shape(uint8_t active_mask) {
     bool has_aic = (active_mask & PTO2_SUBTASK_MASK_AIC) != 0;
-    int aiv_count = ((active_mask & PTO2_SUBTASK_MASK_AIV0) != 0)
-                  + ((active_mask & PTO2_SUBTASK_MASK_AIV1) != 0);
+    int aiv_count = ((active_mask & PTO2_SUBTASK_MASK_AIV0) != 0) + ((active_mask & PTO2_SUBTASK_MASK_AIV1) != 0);
 
     if (has_aic) {
         if (aiv_count == 0) return PTO2ResourceShape::AIC_ONLY;
@@ -86,12 +97,12 @@ static inline PTO2ResourceShape pto2_active_mask_to_shape(uint8_t active_mask) {
 /**
  * Compute active_mask from MixedKernels.
  */
-static inline uint8_t pto2_mixed_kernels_to_active_mask(const MixedKernels& mk) {
+static inline uint8_t pto2_mixed_kernels_to_active_mask(const MixedKernels &mk) {
     uint8_t mask = 0;
-    if (mk.aic_kernel_id  != INVALID_KERNEL_ID) mask |= PTO2_SUBTASK_MASK_AIC;
+    if (mk.aic_kernel_id != INVALID_KERNEL_ID) mask |= PTO2_SUBTASK_MASK_AIC;
     if (mk.aiv0_kernel_id != INVALID_KERNEL_ID) mask |= PTO2_SUBTASK_MASK_AIV0;
     if (mk.aiv1_kernel_id != INVALID_KERNEL_ID) mask |= PTO2_SUBTASK_MASK_AIV1;
     return mask;
 }
 
-#endif // PTO_SUBMIT_TYPES_H
+#endif  // PTO_SUBMIT_TYPES_H