(partial) Clang-tidy automatic sweep after pulling in latest main

tt_metal/impl/buffers/buffer.cpp

@@ -522,17 +522,17 @@ DeviceAddr ShardSpecBuffer::size() const {
 
 v1::BufferHandle v1::CreateBuffer(InterleavedBufferConfig config) { return v1::BufferHandle{v0::CreateBuffer(config)}; }
 
-void v1::DeallocateBuffer(BufferHandle buffer) { v0::DeallocateBuffer(*buffer); }
+void v1::DeallocateBuffer(const BufferHandle& buffer) { v0::DeallocateBuffer(*buffer); }
 
-void v1::WriteToBuffer(BufferHandle buffer, stl::Span<const std::byte> host_buffer) {
+void v1::WriteToBuffer(const BufferHandle& buffer, stl::Span<const std::byte> host_buffer) {
     detail::WriteToBuffer(*buffer, stl::Span<const uint8_t>{reinterpret_cast<const std::uint8_t *>(host_buffer.data()), host_buffer.size()});
 }
 
-void v1::ReadFromBuffer(BufferHandle buffer, stl::Span<std::byte> host_buffer, bool shard_order) {
+void v1::ReadFromBuffer(const BufferHandle& buffer, stl::Span<std::byte> host_buffer, bool shard_order) {
     detail::ReadFromBuffer(*buffer, reinterpret_cast<std::uint8_t *>(host_buffer.data()), shard_order);
 }
 
-void v1::ReadFromShard(BufferHandle buffer, stl::Span<std::byte> host_buffer, std::uint32_t core_id) {
+void v1::ReadFromShard(const BufferHandle& buffer, stl::Span<std::byte> host_buffer, std::uint32_t core_id) {
     detail::ReadShard(*buffer, reinterpret_cast<std::uint8_t *>(host_buffer.data()), core_id);
 }
 

tt_metal/impl/dispatch/command_queue.cpp

@@ -3504,11 +3504,11 @@ v1::CommandQueueHandle v1::GetCommandQueue(DeviceHandle device, std::uint8_t cq_
 
 v1::CommandQueueHandle v1::GetDefaultCommandQueue(DeviceHandle device) { return GetCommandQueue(device, 0); }
 
-void v1::EnqueueReadBuffer(CommandQueueHandle cq, BufferHandle buffer, std::byte *dst, bool blocking) {
+void v1::EnqueueReadBuffer(CommandQueueHandle cq, const BufferHandle& buffer, std::byte *dst, bool blocking) {
     v0::EnqueueReadBuffer(GetDevice(cq)->command_queue(GetId(cq)), *buffer, dst, blocking);
 }
 
-void v1::EnqueueWriteBuffer(CommandQueueHandle cq, BufferHandle buffer, const std::byte *src, bool blocking) {
+void v1::EnqueueWriteBuffer(CommandQueueHandle cq, const BufferHandle& buffer, const std::byte *src, bool blocking) {
     v0::EnqueueWriteBuffer(GetDevice(cq)->command_queue(GetId(cq)), *buffer, src, blocking);
 }
 

tt_metal/impl/event/event.cpp

@@ -37,16 +37,16 @@ v1::EventHandle v1::EnqueueRecordEvent(CommandQueueHandle cq) {
     return event;
 }
 
-void v1::EnqueueWaitForEvent(CommandQueueHandle cq, EventHandle event) {
+void v1::EnqueueWaitForEvent(CommandQueueHandle cq, const EventHandle& event) {
     v0::EnqueueWaitForEvent(
         GetDevice(cq)->command_queue(GetId(cq)), static_cast<const std::shared_ptr<v0::Event> &>(event));
 }
 
-void v1::EventSynchronize(EventHandle event) {
+void v1::EventSynchronize(const EventHandle& event) {
     v0::EventSynchronize(static_cast<const std::shared_ptr<v0::Event> &>(event));
 }
 
-bool v1::EventQuery(EventHandle event) {
+bool v1::EventQuery(const EventHandle& event) {
     return v0::EventQuery(static_cast<const std::shared_ptr<v0::Event> &>(event));
 }
 

tt_metal/include/tt_metal/buffer.hpp

@@ -26,15 +26,15 @@ BufferHandle CreateBuffer(InterleavedBufferConfig config);
  *
  * @param buffer The buffer to deallocate.
  */
-void DeallocateBuffer(BufferHandle buffer);
+void DeallocateBuffer(const BufferHandle& buffer);
 
 /**
  * @brief Copies data from a host buffer into the specified device buffer.
  *
  * @param buffer Buffer to write data into.
  * @param host_buffer Host buffer containing data to copy.
  */
-void WriteToBuffer(BufferHandle buffer, stl::Span<const std::byte> host_buffer);
+void WriteToBuffer(const BufferHandle& buffer, stl::Span<const std::byte> host_buffer);
 
 /**
  * @brief Copies data from a device buffer into a host buffer.
@@ -43,7 +43,7 @@ void WriteToBuffer(BufferHandle buffer, stl::Span<const std::byte> host_buffer);
  * @param host_buffer Host buffer to copy data into.
  * @param shard_order If true, reads data in shard order.
  */
-void ReadFromBuffer(BufferHandle buffer, stl::Span<std::byte> host_buffer, bool shard_order = false);
+void ReadFromBuffer(const BufferHandle& buffer, stl::Span<std::byte> host_buffer, bool shard_order = false);
 
 /**
  * @brief Copies data from a specific shard of a device buffer into a host buffer.
@@ -52,7 +52,7 @@ void ReadFromBuffer(BufferHandle buffer, stl::Span<std::byte> host_buffer, bool
  * @param host_buffer Host buffer to copy data into.
  * @param core_id ID of the core shard to read.
  */
-void ReadFromShard(BufferHandle buffer, stl::Span<std::byte> host_buffer, std::uint32_t core_id);
+void ReadFromShard(const BufferHandle& buffer, stl::Span<std::byte> host_buffer, std::uint32_t core_id);
 
 }  // namespace v1
 }  // namespace tt::tt_metal

tt_metal/include/tt_metal/command_queue.hpp

@@ -41,7 +41,7 @@ CommandQueueHandle GetDefaultCommandQueue(DeviceHandle device);
  */
 void EnqueueReadBuffer(
     CommandQueueHandle cq,
-    BufferHandle buffer,
+    const BufferHandle& buffer,
     std::byte *dst,
     bool blocking);
 
@@ -55,7 +55,7 @@ void EnqueueReadBuffer(
  */
 void EnqueueWriteBuffer(
     CommandQueueHandle cq,
-    BufferHandle buffer,
+    const BufferHandle& buffer,
     const std::byte *src,
     bool blocking);
 

tt_metal/include/tt_metal/event.hpp

@@ -27,22 +27,22 @@ EventHandle EnqueueRecordEvent(CommandQueueHandle cq);
  * @param cq The command queue that will wait for the event.
  * @param event Handle to the Event object to wait on.
  */
-void EnqueueWaitForEvent(CommandQueueHandle cq, EventHandle event);
+void EnqueueWaitForEvent(CommandQueueHandle cq, const EventHandle& event);
 
 /**
  * @brief Blocks the host until the specified event has completed on the device.
  *
  * @param event Handle to the Event object to synchronize.
  */
-void EventSynchronize(EventHandle event);
+void EventSynchronize(const EventHandle& event);
 
 /**
  * @brief Queries the completion status of an event on the device.
  *
  * @param event Handle to the Event object to query.
  * @return True if the event is completed; otherwise, false.
  */
-bool EventQuery(EventHandle event);
+bool EventQuery(const EventHandle& event);
 
 
 /**

tt_metal/jit_build/genfiles.cpp

@@ -179,7 +179,7 @@ generate_unpack_data_formats(tt_hlk_desc& desc, DataFormat unpack_conditional_ds
     vector<DataFormat> src_formats = tt::get_unpack_src_formats(desc.buf_dataformat_arr);
 
     vector<DataFormat> dst_formats = tt::get_unpack_dst_formats(
-        desc.buf_dataformat_arr, unpack_conditional_dst_format, fp32_dest_acc_en, unpack_to_dest_mode);
+        desc.buf_dataformat_arr, unpack_conditional_dst_format, fp32_dest_acc_en, std::move(unpack_to_dest_mode));
 
     TT_ASSERT(src_formats.size() == NUM_CIRCULAR_BUFFERS);
     TT_ASSERT(dst_formats.size() == NUM_CIRCULAR_BUFFERS);

ttnn/cpp/ttnn/operations/eltwise/binary/binary_composite.hpp

@@ -78,15 +78,15 @@ struct ExecuteDiv
         const Tensor& input_tensor_a,
         const Tensor& input_tensor_b,
         bool accurate_mode = false,
-        const std::optional<std::string> round_mode = std::nullopt,
+        const std::optional<std::string>& round_mode = std::nullopt,
         const std::optional<MemoryConfig>& memory_config = std::nullopt,
         std::optional<Tensor> optional_output_tensor = std::nullopt);
 
     static Tensor invoke(
         const Tensor& input_tensor,
         float value,
         bool accurate_mode = false,
-        const std::optional<std::string> round_mode = std::nullopt,
+        const std::optional<std::string>& round_mode = std::nullopt,
         const std::optional<MemoryConfig>& memory_config = std::nullopt,
         std::optional<Tensor> optional_output_tensor = std::nullopt);
 
@@ -95,7 +95,7 @@ struct ExecuteDiv
         const Tensor& input_tensor_a,
         const Tensor& input_tensor_b,
         bool accurate_mode = false,
-        const std::optional<std::string> round_mode = std::nullopt,
+        const std::optional<std::string>& round_mode = std::nullopt,
         const std::optional<MemoryConfig>& memory_config = std::nullopt,
         std::optional<Tensor> optional_output_tensor = std::nullopt);
 
@@ -104,7 +104,7 @@ struct ExecuteDiv
         const Tensor& input_tensor,
         float value,
         bool accurate_mode = false,
-        const std::optional<std::string> round_mode = std::nullopt,
+        const std::optional<std::string>& round_mode = std::nullopt,
         const std::optional<MemoryConfig>& memory_config = std::nullopt,
         std::optional<Tensor> optional_output_tensor = std::nullopt);
 };

ttnn/cpp/ttnn/operations/eltwise/binary/device/binary_composite_op.cpp

@@ -172,7 +172,7 @@ Tensor _atan2(const Tensor& input_a, const Tensor& input_b, const std::optional<
 }
 
 
-Tensor ExecuteDiv::invoke(uint8_t queue_id, const Tensor& input, float value, bool accurate_mode, const std::optional<std::string> round_mode, const std::optional<MemoryConfig>& output_mem_config, std::optional<Tensor> output_tensor) {
+Tensor ExecuteDiv::invoke(uint8_t queue_id, const Tensor& input, float value, bool accurate_mode, const std::optional<std::string>& round_mode, const std::optional<MemoryConfig>& output_mem_config, std::optional<Tensor> output_tensor) {
     TT_FATAL((round_mode == std::nullopt || round_mode == "trunc" || round_mode == "floor"), "Incorrect rounding mode (expected None, 'trunc', or 'floor')");
     output_tensor = output_tensor.value_or(ttnn::zeros_like(input));
     ttnn::multiply(queue_id, input, (1.0f/value), std::nullopt, output_mem_config, output_tensor);
@@ -185,11 +185,11 @@ Tensor ExecuteDiv::invoke(uint8_t queue_id, const Tensor& input, float value, bo
     return output_tensor.value();
 }
 
-Tensor ExecuteDiv::invoke(const Tensor& input, float value, bool accurate_mode, const std::optional<std::string> round_mode, const std::optional<MemoryConfig>& output_mem_config, std::optional<Tensor> output_tensor) {
-   return ExecuteDiv::invoke(DefaultQueueId, input, value, accurate_mode, round_mode, output_mem_config, output_tensor);
+Tensor ExecuteDiv::invoke(const Tensor& input, float value, bool accurate_mode, const std::optional<std::string>& round_mode, const std::optional<MemoryConfig>& output_mem_config, std::optional<Tensor> output_tensor) {
+   return ExecuteDiv::invoke(DefaultQueueId, input, value, accurate_mode, round_mode, output_mem_config, std::move(output_tensor));
 }
 
-Tensor ExecuteDiv::invoke(uint8_t queue_id, const Tensor& input_a, const Tensor& input_b, bool accurate_mode, const std::optional<std::string> round_mode, const std::optional<MemoryConfig>& output_mem_config, std::optional<Tensor> output_tensor) {
+Tensor ExecuteDiv::invoke(uint8_t queue_id, const Tensor& input_a, const Tensor& input_b, bool accurate_mode, const std::optional<std::string>& round_mode, const std::optional<MemoryConfig>& output_mem_config, std::optional<Tensor> output_tensor) {
     TT_FATAL((round_mode == std::nullopt || round_mode == "trunc" || round_mode == "floor"), "Incorrect rounding mode (expected None, 'trunc', or 'floor')");
     output_tensor = output_tensor.value_or(ttnn::empty_like(input_a));
     auto arch = input_a.device()->arch();
@@ -256,8 +256,8 @@ Tensor ExecuteDiv::invoke(uint8_t queue_id, const Tensor& input_a, const Tensor&
     }
 }
 
-Tensor ExecuteDiv::invoke(const Tensor& input_a, const Tensor& input_b, bool accurate_mode, const std::optional<std::string> round_mode, const std::optional<MemoryConfig>& output_mem_config, std::optional<Tensor> output_tensor) {
-   return ExecuteDiv::invoke(DefaultQueueId, input_a, input_b, accurate_mode, round_mode, output_mem_config, output_tensor);
+Tensor ExecuteDiv::invoke(const Tensor& input_a, const Tensor& input_b, bool accurate_mode, const std::optional<std::string>& round_mode, const std::optional<MemoryConfig>& output_mem_config, std::optional<Tensor> output_tensor) {
+   return ExecuteDiv::invoke(DefaultQueueId, input_a, input_b, accurate_mode, round_mode, output_mem_config, std::move(output_tensor));
 }
 
 Tensor _div_no_nan_overload(const Tensor& input_a, float value, const std::optional<MemoryConfig>& output_mem_config) {

ttnn/cpp/ttnn/operations/eltwise/binary_backward/binary_backward.cpp

@@ -604,7 +604,7 @@ std::vector<ttnn::Tensor> ExecuteBackwardMin::invoke(const Tensor& grad, const T
 }
 
 std::vector<std::optional<ttnn::Tensor>> ExecuteBackwardDiv::invoke(
-    uint8_t queue_id, const Tensor& grad, const Tensor& input, float scalar, const std::optional<std::string> round_mode, const std::optional<MemoryConfig>& output_mem_config, std::optional<Tensor> input_grad) {
+    uint8_t queue_id, const Tensor& grad, const Tensor& input, float scalar, const std::optional<std::string>& round_mode, const std::optional<MemoryConfig>& output_mem_config, std::optional<Tensor> input_grad) {
     TT_FATAL((round_mode == std::nullopt || round_mode == "trunc" || round_mode == "floor"), "Incorrect rounding mode (expected None, 'trunc', or 'floor')");
 
     std::vector<std::optional<Tensor>> result;
@@ -629,16 +629,16 @@ std::vector<std::optional<ttnn::Tensor>> ExecuteBackwardDiv::invoke(
 }
 
 std::vector<std::optional<ttnn::Tensor>> ExecuteBackwardDiv::invoke(
-    const Tensor& grad, const Tensor& input, float scalar, const std::optional<std::string> round_mode, const std::optional<MemoryConfig>& output_mem_config, std::optional<Tensor> input_grad) {
-    return ExecuteBackwardDiv::invoke(DefaultQueueId, grad, input, scalar, round_mode, output_mem_config, input_grad);
+    const Tensor& grad, const Tensor& input, float scalar, const std::optional<std::string>& round_mode, const std::optional<MemoryConfig>& output_mem_config, std::optional<Tensor> input_grad) {
+    return ExecuteBackwardDiv::invoke(DefaultQueueId, grad, input, scalar, round_mode, output_mem_config, std::move(input_grad));
 }
 
 std::vector<std::optional<ttnn::Tensor>> ExecuteBackwardDiv::invoke(
     uint8_t queue_id,
     const Tensor& grad,
     const Tensor& input,
     const Tensor& other,
-    const std::optional<std::string> round_mode,
+    const std::optional<std::string>& round_mode,
     const std::vector<bool>& are_required_outputs,
     const std::optional<MemoryConfig>& output_mem_config,
     std::optional<Tensor> input_grad,
@@ -716,7 +716,7 @@ std::vector<std::optional<ttnn::Tensor>> ExecuteBackwardDiv::invoke(
     const Tensor& grad,
     const Tensor& input,
     const Tensor& other,
-    const std::optional<std::string> round_mode,
+    const std::optional<std::string>& round_mode,
     const std::vector<bool>& are_required_outputs,
     const std::optional<MemoryConfig>& output_mem_config,
     std::optional<Tensor> input_grad,

ttnn/cpp/ttnn/operations/eltwise/binary_backward/binary_backward.hpp

@@ -314,7 +314,7 @@ struct ExecuteBackwardDiv  {
         const Tensor &grad_tensor_arg,
         const Tensor &input_tensor_arg,
         float scalar,
-        const std::optional<string> round_mode = std::nullopt,
+        const std::optional<string>& round_mode = std::nullopt,
         const std::optional<MemoryConfig> &memory_config = std::nullopt,
         std::optional<Tensor> input_grad = std::nullopt);
 
@@ -323,7 +323,7 @@ struct ExecuteBackwardDiv  {
         const Tensor &grad_tensor_arg,
         const Tensor &input_tensor_arg,
         const Tensor &other_tensor_arg,
-        const std::optional<string> round_mode = std::nullopt,
+        const std::optional<string>& round_mode = std::nullopt,
         const std::vector<bool> &are_required_outputs = std::vector<bool>{true, true},
         const std::optional<MemoryConfig> &memory_config = std::nullopt,
         std::optional<Tensor> input_grad = std::nullopt,
@@ -333,15 +333,15 @@ struct ExecuteBackwardDiv  {
         const Tensor &grad_tensor_arg,
         const Tensor &input_tensor_arg,
         float scalar,
-        const std::optional<string> round_mode = std::nullopt,
+        const std::optional<string>& round_mode = std::nullopt,
         const std::optional<MemoryConfig> &memory_config = std::nullopt,
         std::optional<Tensor> input_grad = std::nullopt);
 
     static std::vector<std::optional<Tensor>> invoke(
         const Tensor &grad_tensor_arg,
         const Tensor &input_tensor_arg,
         const Tensor &other_tensor_arg,
-        const std::optional<string> round_mode = std::nullopt,
+        const std::optional<string>& round_mode = std::nullopt,
         const std::vector<bool> &are_required_outputs = std::vector<bool>{true, true},
         const std::optional<MemoryConfig> &memory_config = std::nullopt,
         std::optional<Tensor> input_grad = std::nullopt,

ttnn/cpp/ttnn/operations/eltwise/unary/device/unary_composite_op.cpp

@@ -698,7 +698,7 @@ Tensor _polygamma(const Tensor& input_a, int32_t k, const std::optional<MemoryCo
 }
 
 //rdiv
-Tensor ExecuteRdiv::invoke(uint8_t queue_id, const Tensor& input_tensor, float value, const std::optional<std::string> round_mode, const std::optional<MemoryConfig>& memory_config, std::optional<Tensor> optional_output_tensor) {
+Tensor ExecuteRdiv::invoke(uint8_t queue_id, const Tensor& input_tensor, float value, const std::optional<std::string>& round_mode, const std::optional<MemoryConfig>& memory_config, std::optional<Tensor> optional_output_tensor) {
     TT_FATAL((round_mode == std::nullopt || round_mode == "trunc" || round_mode == "floor"), "Incorrect rounding mode (expected None, 'trunc', or 'floor')");
     float t_inf = std::numeric_limits<float>::infinity();
     Tensor recip_result = ttnn::reciprocal(queue_id, input_tensor, memory_config, optional_output_tensor);

ttnn/cpp/ttnn/operations/eltwise/unary/unary_composite.hpp

@@ -168,7 +168,7 @@ struct ExecuteRdiv {
         uint8_t queue_id,
         const Tensor& input_tensor,
         float value,
-        const std::optional<std::string> round_mode = std::nullopt,
+        const std::optional<std::string>& round_mode = std::nullopt,
         const std::optional<MemoryConfig>& memory_config = std::nullopt,
         std::optional<Tensor> optional_output_tensor = std::nullopt);
 };

ttnn/cpp/ttnn/operations/eltwise/unary_backward/unary_backward.cpp

@@ -82,7 +82,7 @@ std::vector<Tensor> ExecuteUnaryBackwardClip::invoke(
 
 std::vector<Tensor> ExecuteUnaryBackwardClip::invoke(
     const Tensor& grad, const Tensor& input, std::optional<Tensor> min, std::optional<Tensor> max, const std::optional<MemoryConfig>& output_mem_config) {
-    return ExecuteUnaryBackwardClamp::invoke(grad, input, min, max, output_mem_config);
+    return ExecuteUnaryBackwardClamp::invoke(grad, input, std::move(min), std::move(max), output_mem_config);
 }
 
 // Hardtanh
@@ -135,7 +135,7 @@ std::vector<Tensor> ExecuteUnaryBackwardSoftplus::invoke(
 }
 
 std::vector<Tensor> ExecuteUnaryBackwardRdiv::invoke(
-    const Tensor& grad, const Tensor& input, float scalar, const std::optional<string> round_mode, const std::optional<MemoryConfig>& output_mem_config) {
+    const Tensor& grad, const Tensor& input, float scalar, const std::optional<string>& round_mode, const std::optional<MemoryConfig>& output_mem_config) {
     std::vector<Tensor> grad_tensor;
     TT_FATAL((round_mode == std::nullopt || round_mode == "trunc" || round_mode == "floor"), "Incorrect rounding mode (expected None, 'trunc', or 'floor')");
     float t_nan = std::nanf("");

ttnn/cpp/ttnn/operations/eltwise/unary_backward/unary_backward.hpp

@@ -488,7 +488,7 @@ struct ExecuteUnaryBackwardRdiv {
         const Tensor &grad_tensor_arg,
         const Tensor &input_tensor_arg,
         float parameter_a,
-        const std::optional<string> parameter_b = std::nullopt,
+        const std::optional<string>& parameter_b = std::nullopt,
         const std::optional<MemoryConfig> &memory_config = std::nullopt);
 };
 

ttnn/cpp/ttnn/operations/experimental/paged_cache/device/paged_fused_update_cache_program_factory.cpp

@@ -142,7 +142,7 @@ UpdateCacheKernels setup_kernels_for_update_cache(
     return {unary_reader_kernel_id, unary_writer_kernel_id, compute_kernel_id, cores};
 }
 
-operation::ProgramWithCallbacks paged_fused_update_cache_multi_core(const Tensor& cache_tensor1, const Tensor &input_tensor1, const Tensor& cache_tensor2, const Tensor &input_tensor2, std::optional<const Tensor> update_idxs_tensor, std::optional<const Tensor> page_table, const std::vector<uint32_t> update_idxs, const uint32_t batch_offset, ttnn::DeviceComputeKernelConfig compute_kernel_config, const bool share_cache) {
+operation::ProgramWithCallbacks paged_fused_update_cache_multi_core(const Tensor& cache_tensor1, const Tensor &input_tensor1, const Tensor& cache_tensor2, const Tensor &input_tensor2, std::optional<const Tensor> update_idxs_tensor, std::optional<const Tensor> page_table, const std::vector<uint32_t>& update_idxs, const uint32_t batch_offset, ttnn::DeviceComputeKernelConfig compute_kernel_config, const bool share_cache) {
     Program program{};
 
     uint32_t num_caches = 2;