renaming it back to Tensor

Author: Edwardius

deep_core/DEVELOPING.md

@@ -2,7 +2,7 @@
 
 ## Design Principles
 
-- TensorPtr is a smart pointer, not a traditional tensor class, it points to data in memory allocated by the backend memory allocator
+- Tensor is a smart pointer, not a traditional tensor class, it points to data in memory allocated by the backend memory allocator
 - DeepNodeBase handles plugin loading automatically via parameters
 - All backends are plugins - no hard framework dependencies
 - Memory allocators enable zero-copy GPU integration
@@ -37,7 +37,7 @@ Key lifecycle callbacks to override:
 
 **Your node just needs to:**
 - Set up ROS interfaces (topics, services, actions)
-- Process incoming data using `run_inference(TensorPtr)`
+- Process incoming data using `run_inference(Tensor)`
 - Handle your specific business logic
 
 Don't forget: `RCLCPP_COMPONENTS_REGISTER_NODE(your_namespace::YourNode)`

deep_core/README.md

@@ -5,13 +5,13 @@ Core abstractions for ML inference in ROS 2 lifecycle nodes.
 ## Overview
 
 Provides:
-- `TensorPtr`: Smart pointer for tensor data with custom memory allocators
+- `Tensor`: Smart pointer for tensor data with custom memory allocators
 - `DeepNodeBase`: Lifecycle node base class with plugin loading and optional bond support
 - Plugin interfaces for backend inference engines and memory management
 
 ## Key Components
 
-### TensorPtr
+### Tensor
 Multi-dimensional tensor smart pointer supporting:
 - Custom memory allocators (CPU/GPU/aligned memory)
 - View semantics (wrap existing data without copying)

deep_core/include/deep_core/deep_node_base.hpp

@@ -133,7 +133,7 @@ class DeepNodeBase : public rclcpp_lifecycle::LifecycleNode
    * @param inputs Input tensor for inference
    * @return Output tensor from inference
    */
-  TensorPtr run_inference(TensorPtr inputs);
+  Tensor run_inference(Tensor inputs);
 
   /**
    * @brief Check if a backend plugin is loaded

deep_core/include/deep_core/plugin_interfaces/backend_inference_executor.hpp

@@ -47,7 +47,7 @@ class BackendInferenceExecutor
    * @param input Input tensor
    * @return Output tensor
    */
-  virtual TensorPtr run_inference(TensorPtr input) = 0;
+  virtual Tensor run_inference(Tensor input) = 0;
 
   /**
    * @brief Unload the currently loaded model

deep_core/include/deep_core/types/tensor.hpp

@@ -51,65 +51,65 @@ size_t get_dtype_size(DataType dtype);
 /**
  * @brief A smart pointer for multi-dimensional tensor data with automatic memory management
  *
- * The TensorPtr class provides a lightweight smart pointer for multi-dimensional arrays
+ * The Tensor class provides a lightweight smart pointer for multi-dimensional arrays
  * with support for different data types. It handles memory allocation automatically
  * and supports both owned and borrowed memory patterns.
  */
-class TensorPtr
+class Tensor
 {
 public:
   /**
    * @brief Default constructor - creates an empty tensor
    */
-  TensorPtr();
+  Tensor();
 
   /**
    * @brief Create a new tensor with specified shape and data type
    * @param shape Dimensions of the tensor
    * @param dtype Data type of tensor elements
    */
-  TensorPtr(const std::vector<size_t> & shape, DataType dtype);
+  Tensor(const std::vector<size_t> & shape, DataType dtype);
 
   /**
    * @brief Create a new tensor with specified shape, data type, and allocator
    * @param shape Dimensions of the tensor
    * @param dtype Data type of tensor elements
    * @param allocator Memory allocator to use (uses CPU allocator if nullptr)
    */
-  TensorPtr(const std::vector<size_t> & shape, DataType dtype, std::shared_ptr<BackendMemoryAllocator> allocator);
+  Tensor(const std::vector<size_t> & shape, DataType dtype, std::shared_ptr<BackendMemoryAllocator> allocator);
 
   /**
    * @brief Wrap existing data in a tensor (non-owning)
    * @param data Pointer to existing data
    * @param shape Dimensions of the tensor
    * @param dtype Data type of tensor elements
    */
-  TensorPtr(void * data, const std::vector<size_t> & shape, DataType dtype);
+  Tensor(void * data, const std::vector<size_t> & shape, DataType dtype);
 
   /**
    * @brief Destructor - frees owned memory
    */
-  ~TensorPtr();
+  ~Tensor();
 
   /**
    * @brief Copy constructor - creates a deep copy
    */
-  TensorPtr(const TensorPtr & other);
+  Tensor(const Tensor & other);
 
   /**
    * @brief Copy assignment - creates a deep copy
    */
-  TensorPtr & operator=(const TensorPtr & other);
+  Tensor & operator=(const Tensor & other);
 
   /**
    * @brief Move constructor
    */
-  TensorPtr(TensorPtr && other) noexcept;
+  Tensor(Tensor && other) noexcept;
 
   /**
    * @brief Move assignment
    */
-  TensorPtr & operator=(TensorPtr && other) noexcept;
+  Tensor & operator=(Tensor && other) noexcept;
 
   /**
    * @brief Get tensor dimensions
@@ -201,7 +201,7 @@ class TensorPtr
    * @param new_shape New dimensions (total size must match)
    * @return New tensor view with different shape
    */
-  TensorPtr reshape(const std::vector<size_t> & new_shape) const;
+  Tensor reshape(const std::vector<size_t> & new_shape) const;
 
   /**
    * @brief Get total number of elements

deep_core/src/deep_node_base.cpp

@@ -176,7 +176,7 @@ void DeepNodeBase::unload_model()
   }
 }
 
-TensorPtr DeepNodeBase::run_inference(TensorPtr inputs)
+Tensor DeepNodeBase::run_inference(Tensor inputs)
 {
   if (!plugin_) {
     throw std::runtime_error("No plugin loaded");

deep_core/src/tensor.cpp

@@ -57,26 +57,24 @@ size_t get_dtype_size(DataType dtype)
   }
 }
 
-TensorPtr::TensorPtr()
+Tensor::Tensor()
 : dtype_(DataType::FLOAT32)
 , byte_size_(0)
 , data_(nullptr)
 , is_view_(false)
 , allocator_(nullptr)
 {}
 
-TensorPtr::TensorPtr(const std::vector<size_t> & shape, DataType dtype)
+Tensor::Tensor(const std::vector<size_t> & shape, DataType dtype)
 : shape_(shape)
 , dtype_(dtype)
 , is_view_(false)
 , allocator_(nullptr)
 {
-  throw std::runtime_error(
-    "TensorPtr construction requires an allocator. Use TensorPtr(shape, dtype, allocator) instead.");
+  throw std::runtime_error("Tensor construction requires an allocator. Use Tensor(shape, dtype, allocator) instead.");
 }
 
-TensorPtr::TensorPtr(
-  const std::vector<size_t> & shape, DataType dtype, std::shared_ptr<BackendMemoryAllocator> allocator)
+Tensor::Tensor(const std::vector<size_t> & shape, DataType dtype, std::shared_ptr<BackendMemoryAllocator> allocator)
 : shape_(shape)
 , dtype_(dtype)
 , is_view_(false)
@@ -94,7 +92,7 @@ TensorPtr::TensorPtr(
   allocate_memory();
 }
 
-TensorPtr::TensorPtr(void * data, const std::vector<size_t> & shape, DataType dtype)
+Tensor::Tensor(void * data, const std::vector<size_t> & shape, DataType dtype)
 : shape_(shape)
 , dtype_(dtype)
 , data_(data)
@@ -111,12 +109,12 @@ TensorPtr::TensorPtr(void * data, const std::vector<size_t> & shape, DataType dt
   byte_size_ = total_elements * get_dtype_size(dtype_);
 }
 
-TensorPtr::~TensorPtr()
+Tensor::~Tensor()
 {
   deallocate_memory();
 }
 
-TensorPtr::TensorPtr(const TensorPtr & other)
+Tensor::Tensor(const Tensor & other)
 : shape_(other.shape_)
 , strides_(other.strides_)
 , dtype_(other.dtype_)
@@ -136,7 +134,7 @@ TensorPtr::TensorPtr(const TensorPtr & other)
   }
 }
 
-TensorPtr & TensorPtr::operator=(const TensorPtr & other)
+Tensor & Tensor::operator=(const Tensor & other)
 {
   if (this != &other) {
     deallocate_memory();
@@ -162,7 +160,7 @@ TensorPtr & TensorPtr::operator=(const TensorPtr & other)
   return *this;
 }
 
-TensorPtr::TensorPtr(TensorPtr && other) noexcept
+Tensor::Tensor(Tensor && other) noexcept
 : shape_(std::move(other.shape_))
 , strides_(std::move(other.strides_))
 , dtype_(other.dtype_)
@@ -177,7 +175,7 @@ TensorPtr::TensorPtr(TensorPtr && other) noexcept
   other.allocator_ = nullptr;
 }
 
-TensorPtr & TensorPtr::operator=(TensorPtr && other) noexcept
+Tensor & Tensor::operator=(Tensor && other) noexcept
 {
   if (this != &other) {
     deallocate_memory();
@@ -198,7 +196,7 @@ TensorPtr & TensorPtr::operator=(TensorPtr && other) noexcept
   return *this;
 }
 
-void TensorPtr::calculate_strides()
+void Tensor::calculate_strides()
 {
   strides_.resize(shape_.size());
   if (shape_.empty()) return;
@@ -209,7 +207,7 @@ void TensorPtr::calculate_strides()
   }
 }
 
-void TensorPtr::allocate_memory()
+void Tensor::allocate_memory()
 {
   if (byte_size_ > 0 && !is_view_) {
     if (allocator_) {
@@ -223,7 +221,7 @@ void TensorPtr::allocate_memory()
   }
 }
 
-void TensorPtr::deallocate_memory()
+void Tensor::deallocate_memory()
 {
   if (!is_view_ && data_) {
     if (allocator_) {
@@ -235,7 +233,7 @@ void TensorPtr::deallocate_memory()
   }
 }
 
-TensorPtr TensorPtr::reshape(const std::vector<size_t> & new_shape) const
+Tensor Tensor::reshape(const std::vector<size_t> & new_shape) const
 {
   size_t new_total = std::accumulate(new_shape.begin(), new_shape.end(), 1UL, std::multiplies<size_t>());
   size_t current_total = std::accumulate(shape_.begin(), shape_.end(), 1UL, std::multiplies<size_t>());
@@ -248,15 +246,15 @@ TensorPtr TensorPtr::reshape(const std::vector<size_t> & new_shape) const
     throw std::runtime_error("Cannot reshape non-contiguous tensor");
   }
 
-  return TensorPtr(data_, new_shape, dtype_);
+  return Tensor(data_, new_shape, dtype_);
 }
 
-size_t TensorPtr::size() const
+size_t Tensor::size() const
 {
   return std::accumulate(shape_.begin(), shape_.end(), 1UL, std::multiplies<size_t>());
 }
 
-bool TensorPtr::is_contiguous() const
+bool Tensor::is_contiguous() const
 {
   if (shape_.empty()) return true;
 

deep_core/test/test_deep_core.cpp

@@ -80,12 +80,12 @@ class MockMemoryAllocator : public BackendMemoryAllocator
   size_t allocated_bytes_{0};
 };
 
-TEST_CASE("TensorPtr construction with allocator", "[tensor]")
+TEST_CASE("Tensor construction with allocator", "[tensor]")
 {
   auto allocator = std::make_shared<MockMemoryAllocator>();
   std::vector<size_t> shape{2, 3, 4};
 
-  TensorPtr tensor(shape, DataType::FLOAT32, allocator);
+  Tensor tensor(shape, DataType::FLOAT32, allocator);
 
   REQUIRE(tensor.shape() == shape);
   REQUIRE(tensor.dtype() == DataType::FLOAT32);
@@ -94,20 +94,20 @@ TEST_CASE("TensorPtr construction with allocator", "[tensor]")
   REQUIRE(allocator->allocated_bytes() > 0);
 }
 
-TEST_CASE("TensorPtr construction without allocator throws", "[tensor]")
+TEST_CASE("Tensor construction without allocator throws", "[tensor]")
 {
   std::vector<size_t> shape{2, 3};
-  REQUIRE_THROWS_AS(TensorPtr(shape, DataType::FLOAT32), std::runtime_error);
+  REQUIRE_THROWS_AS(Tensor(shape, DataType::FLOAT32), std::runtime_error);
 }
 
 TEST_CASE("Different data types have correct sizes", "[tensor]")
 {
   auto allocator = std::make_shared<MockMemoryAllocator>();
 
-  TensorPtr float_tensor({10}, DataType::FLOAT32, allocator);
-  TensorPtr int32_tensor({10}, DataType::INT32, allocator);
-  TensorPtr int64_tensor({10}, DataType::INT64, allocator);
-  TensorPtr uint8_tensor({10}, DataType::UINT8, allocator);
+  Tensor float_tensor({10}, DataType::FLOAT32, allocator);
+  Tensor int32_tensor({10}, DataType::INT32, allocator);
+  Tensor int64_tensor({10}, DataType::INT64, allocator);
+  Tensor uint8_tensor({10}, DataType::UINT8, allocator);
 
   REQUIRE(float_tensor.size() == 10);
   REQUIRE(int32_tensor.size() == 10);
@@ -120,15 +120,15 @@ TEST_CASE("Empty shape throws exception", "[tensor]")
   auto allocator = std::make_shared<MockMemoryAllocator>();
   std::vector<size_t> empty_shape;
 
-  REQUIRE_THROWS_AS(TensorPtr(empty_shape, DataType::FLOAT32, allocator), std::invalid_argument);
+  REQUIRE_THROWS_AS(Tensor(empty_shape, DataType::FLOAT32, allocator), std::invalid_argument);
 }
 
 TEST_CASE("Large shape allocation", "[tensor]")
 {
   auto allocator = std::make_shared<MockMemoryAllocator>();
   std::vector<size_t> large_shape{100, 100, 3};
 
-  TensorPtr tensor(large_shape, DataType::UINT8, allocator);
+  Tensor tensor(large_shape, DataType::UINT8, allocator);
 
   REQUIRE(tensor.size() == 30000);
   REQUIRE(tensor.shape() == large_shape);
@@ -144,15 +144,15 @@ class MockBackendExecutor : public BackendInferenceExecutor
     return true;
   }
 
-  TensorPtr run_inference(TensorPtr input) override
+  Tensor run_inference(Tensor input) override
   {
     if (!model_loaded_) {
       throw std::runtime_error("No model loaded");
     }
 
     // Mock inference: return tensor with same shape but all zeros
     auto allocator = std::make_shared<MockMemoryAllocator>();
-    TensorPtr output(input.shape(), input.dtype(), allocator);
+    Tensor output(input.shape(), input.dtype(), allocator);
 
     // Calculate correct byte size based on data type
     size_t dtype_size = get_dtype_size(input.dtype());
@@ -242,7 +242,7 @@ TEST_CASE("Backend inference workflow", "[plugin][inference]")
 
   // Create input tensor
   std::vector<size_t> shape{1, 3, 224, 224};
-  TensorPtr input(shape, DataType::FLOAT32, allocator);
+  Tensor input(shape, DataType::FLOAT32, allocator);
 
   // Run inference
   auto output = executor->run_inference(std::move(input));
@@ -280,7 +280,7 @@ class TestInferenceNode : public DeepNodeBase
     return load_model(model_path);
   }
 
-  TensorPtr test_run_inference(TensorPtr input)
+  Tensor test_run_inference(Tensor input)
   {
     return run_inference(input);
   }