refactor(cuda_utils): prefix package and namespace with autoware

Signed-off-by: Esteve Fernandez <esteve.fernandez@tier4.jp>

Author: esteve

.github/CODEOWNERS

@@ -198,6 +198,7 @@ planning/sampling_based_planner/autoware_bezier_sampler/** maxime.clement@tier4.
 planning/sampling_based_planner/autoware_frenet_planner/** maxime.clement@tier4.jp
 planning/sampling_based_planner/autoware_path_sampler/** maxime.clement@tier4.jp
 planning/sampling_based_planner/autoware_sampler_common/** maxime.clement@tier4.jp
+sensing/autoware_cuda_utils/** amadeusz.szymko.2@tier4.jp kenzo.lobos@tier4.jp manato.hirabayashi@tier4.jp
 sensing/autoware_gnss_poser/** anh.nguyen.2@tier4.jp kento.yabuuchi.2@tier4.jp masahiro.sakamoto@tier4.jp ryu.yamamoto@tier4.jp shintaro.sakoda@tier4.jp taiki.yamada@tier4.jp yamato.ando@tier4.jp
 sensing/autoware_image_diagnostics/** dai.nguyen@tier4.jp yoshi.ri@tier4.jp
 sensing/autoware_image_transport_decompressor/** kenzo.lobos@tier4.jp yukihiro.saito@tier4.jp
@@ -208,7 +209,6 @@ sensing/autoware_radar_scan_to_pointcloud2/** satoshi.tanaka@tier4.jp shunsuke.m
 sensing/autoware_radar_static_pointcloud_filter/** satoshi.tanaka@tier4.jp shunsuke.miura@tier4.jp taekjin.lee@tier4.jp yoshi.ri@tier4.jp
 sensing/autoware_radar_threshold_filter/** satoshi.tanaka@tier4.jp shunsuke.miura@tier4.jp taekjin.lee@tier4.jp yoshi.ri@tier4.jp
 sensing/autoware_radar_tracks_noise_filter/** satoshi.tanaka@tier4.jp shunsuke.miura@tier4.jp taekjin.lee@tier4.jp yoshi.ri@tier4.jp
-sensing/cuda_utils/** amadeusz.szymko.2@tier4.jp kenzo.lobos@tier4.jp manato.hirabayashi@tier4.jp
 sensing/livox/autoware_livox_tag_filter/** kenzo.lobos@tier4.jp ryohsuke.mitsudome@tier4.jp
 sensing/vehicle_velocity_converter/** ryu.yamamoto@tier4.jp
 simulator/autoware_carla_interface/** maxime.clement@tier4.jp mradityagio@gmail.com

perception/autoware_bytetrack/package.xml

@@ -18,7 +18,7 @@
   <depend>autoware_kalman_filter</depend>
   <depend>autoware_perception_msgs</depend>
   <depend>autoware_tensorrt_common</depend>
-  <depend>cuda_utils</depend>
+  <depend>autoware_cuda_utils</depend>
   <depend>cv_bridge</depend>
   <depend>eigen</depend>
   <depend>image_transport</depend>

perception/autoware_lidar_apollo_instance_segmentation/include/autoware/lidar_apollo_instance_segmentation/detector.hpp

@@ -21,8 +21,8 @@
 
 #include <autoware/tensorrt_common/tensorrt_common.hpp>
 #include <autoware/universe_utils/transform/transforms.hpp>
-#include <cuda_utils/cuda_unique_ptr.hpp>
-#include <cuda_utils/stream_unique_ptr.hpp>
+#include <autoware/cuda_utils/cuda_unique_ptr.hpp>
+#include <autoware/cuda_utils/stream_unique_ptr.hpp>
 #include <tf2_eigen/tf2_eigen.hpp>
 
 #include <tf2_ros/buffer_interface.h>
@@ -35,10 +35,10 @@ namespace autoware
 {
 namespace lidar_apollo_instance_segmentation
 {
-using cuda_utils::CudaUniquePtr;
-using cuda_utils::CudaUniquePtrHost;
-using cuda_utils::makeCudaStream;
-using cuda_utils::StreamUniquePtr;
+using autoware::cuda_utils::CudaUniquePtr;
+using autoware::cuda_utils::CudaUniquePtrHost;
+using autoware::cuda_utils::makeCudaStream;
+using autoware::cuda_utils::StreamUniquePtr;
 
 class LidarApolloInstanceSegmentation : public LidarInstanceSegmentationInterface
 {

perception/autoware_lidar_apollo_instance_segmentation/package.xml

@@ -16,7 +16,7 @@
   <depend>autoware_perception_msgs</depend>
   <depend>autoware_tensorrt_common</depend>
   <depend>autoware_universe_utils</depend>
-  <depend>cuda_utils</depend>
+  <depend>autoware_cuda_utils</depend>
   <depend>libpcl-all-dev</depend>
   <depend>pcl_conversions</depend>
   <depend>rclcpp</depend>

perception/autoware_lidar_apollo_instance_segmentation/src/detector.cpp

@@ -65,12 +65,12 @@ LidarApolloInstanceSegmentation::LidarApolloInstanceSegmentation(rclcpp::Node *
   const auto input_dims = trt_common_->getBindingDimensions(0);
   const auto input_size =
     std::accumulate(input_dims.d + 1, input_dims.d + input_dims.nbDims, 1, std::multiplies<int>());
-  input_d_ = cuda_utils::make_unique<float[]>(input_size);
+  input_d_ = autoware::cuda_utils::make_unique<float[]>(input_size);
   const auto output_dims = trt_common_->getBindingDimensions(1);
   output_size_ = std::accumulate(
     output_dims.d + 1, output_dims.d + output_dims.nbDims, 1, std::multiplies<int>());
-  output_d_ = cuda_utils::make_unique<float[]>(output_size_);
-  output_h_ = cuda_utils::make_unique_host<float[]>(output_size_, cudaHostAllocPortable);
+  output_d_ = autoware::cuda_utils::make_unique<float[]>(output_size_);
+  output_h_ = autoware::cuda_utils::make_unique_host<float[]>(output_size_, cudaHostAllocPortable);
 
   // feature map generator: pre process
   feature_generator_ = std::make_shared<FeatureGenerator>(

perception/autoware_shape_estimation/include/autoware/shape_estimation/tensorrt_shape_estimator.hpp

@@ -16,9 +16,9 @@
 #define AUTOWARE__SHAPE_ESTIMATION__TENSORRT_SHAPE_ESTIMATOR_HPP_
 
 #include <autoware/tensorrt_common/tensorrt_common.hpp>
-#include <cuda_utils/cuda_check_error.hpp>
-#include <cuda_utils/cuda_unique_ptr.hpp>
-#include <cuda_utils/stream_unique_ptr.hpp>
+#include <autoware/cuda_utils/cuda_check_error.hpp>
+#include <autoware/cuda_utils/cuda_unique_ptr.hpp>
+#include <autoware/cuda_utils/stream_unique_ptr.hpp>
 #include <pcl_ros/transforms.hpp>
 
 #include <autoware_perception_msgs/msg/detected_objects.hpp>
@@ -34,10 +34,10 @@
 
 namespace autoware::shape_estimation
 {
-using cuda_utils::CudaUniquePtr;
-using cuda_utils::CudaUniquePtrHost;
-using cuda_utils::makeCudaStream;
-using cuda_utils::StreamUniquePtr;
+using autoware::cuda_utils::CudaUniquePtr;
+using autoware::cuda_utils::CudaUniquePtrHost;
+using autoware::cuda_utils::makeCudaStream;
+using autoware::cuda_utils::StreamUniquePtr;
 
 using autoware_perception_msgs::msg::DetectedObject;
 using autoware_perception_msgs::msg::DetectedObjects;

perception/autoware_shape_estimation/lib/tensorrt_shape_estimator.cpp

@@ -41,32 +41,32 @@ TrtShapeEstimator::TrtShapeEstimator(
   const auto pc_input_dims = trt_common_->getBindingDimensions(0);
   const auto pc_input_size = std::accumulate(
     pc_input_dims.d + 1, pc_input_dims.d + pc_input_dims.nbDims, 1, std::multiplies<int>());
-  input_pc_d_ = cuda_utils::make_unique<float[]>(pc_input_size * batch_config[2]);
+  input_pc_d_ = autoware::cuda_utils::make_unique<float[]>(pc_input_size * batch_config[2]);
   batch_size_ = batch_config[2];
   const auto one_hot_input_dims = trt_common_->getBindingDimensions(1);
   const auto one_hot_input_size = std::accumulate(
     one_hot_input_dims.d + 1, one_hot_input_dims.d + one_hot_input_dims.nbDims, 1,
     std::multiplies<int>());
-  input_one_hot_d_ = cuda_utils::make_unique<float[]>(one_hot_input_size * batch_config[2]);
+  input_one_hot_d_ = autoware::cuda_utils::make_unique<float[]>(one_hot_input_size * batch_config[2]);
 
   const auto stage1_center_out_dims = trt_common_->getBindingDimensions(2);
   out_s1center_elem_num_ = std::accumulate(
     stage1_center_out_dims.d + 1, stage1_center_out_dims.d + stage1_center_out_dims.nbDims, 1,
     std::multiplies<int>());
   out_s1center_elem_num_ = out_s1center_elem_num_ * batch_config[2];
   out_s1center_elem_num_per_batch_ = static_cast<size_t>(out_s1center_elem_num_ / batch_config[2]);
-  out_s1center_prob_d_ = cuda_utils::make_unique<float[]>(out_s1center_elem_num_);
+  out_s1center_prob_d_ = autoware::cuda_utils::make_unique<float[]>(out_s1center_elem_num_);
   out_s1center_prob_h_ =
-    cuda_utils::make_unique_host<float[]>(out_s1center_elem_num_, cudaHostAllocPortable);
+    autoware::cuda_utils::make_unique_host<float[]>(out_s1center_elem_num_, cudaHostAllocPortable);
 
   const auto pred_out_dims = trt_common_->getBindingDimensions(3);
   out_pred_elem_num_ = std::accumulate(
     pred_out_dims.d + 1, pred_out_dims.d + pred_out_dims.nbDims, 1, std::multiplies<int>());
   out_pred_elem_num_ = out_pred_elem_num_ * batch_config[2];
   out_pred_elem_num_per_batch_ = static_cast<size_t>(out_pred_elem_num_ / batch_config[2]);
-  out_pred_prob_d_ = cuda_utils::make_unique<float[]>(out_pred_elem_num_);
+  out_pred_prob_d_ = autoware::cuda_utils::make_unique<float[]>(out_pred_elem_num_);
   out_pred_prob_h_ =
-    cuda_utils::make_unique_host<float[]>(out_pred_elem_num_, cudaHostAllocPortable);
+    autoware::cuda_utils::make_unique_host<float[]>(out_pred_elem_num_, cudaHostAllocPortable);
 
   g_type_mean_size_ = {{4.6344314, 1.9600292, 1.7375569},     {6.936331, 2.5178623, 2.8506238},
                        {11.194943, 2.9501154, 3.4918275},     {12.275775, 2.9231303, 3.87086},

perception/autoware_shape_estimation/package.xml

@@ -20,7 +20,7 @@
   <depend>autoware_perception_msgs</depend>
   <depend>autoware_tensorrt_common</depend>
   <depend>autoware_universe_utils</depend>
-  <depend>cuda_utils</depend>
+  <depend>autoware_cuda_utils</depend>
   <depend>eigen</depend>
   <depend>libopencv-dev</depend>
   <depend>libpcl-all-dev</depend>

perception/autoware_tensorrt_classifier/include/autoware/tensorrt_classifier/calibrator.hpp

@@ -36,8 +36,8 @@
 
 #ifndef AUTOWARE__TENSORRT_CLASSIFIER__CALIBRATOR_HPP_
 #define AUTOWARE__TENSORRT_CLASSIFIER__CALIBRATOR_HPP_
-#include "cuda_utils/cuda_check_error.hpp"
-#include "cuda_utils/cuda_unique_ptr.hpp"
+#include "autoware/cuda_utils/cuda_check_error.hpp"
+#include "autoware/cuda_utils/cuda_unique_ptr.hpp"
 
 #include <opencv2/core/core.hpp>
 #include <opencv2/highgui/highgui.hpp>

perception/autoware_tensorrt_classifier/include/autoware/tensorrt_classifier/tensorrt_classifier.hpp

@@ -16,9 +16,9 @@
 #define AUTOWARE__TENSORRT_CLASSIFIER__TENSORRT_CLASSIFIER_HPP_
 
 #include <autoware/tensorrt_common/tensorrt_common.hpp>
-#include <cuda_utils/cuda_check_error.hpp>
-#include <cuda_utils/cuda_unique_ptr.hpp>
-#include <cuda_utils/stream_unique_ptr.hpp>
+#include <autoware/cuda_utils/cuda_check_error.hpp>
+#include <autoware/cuda_utils/cuda_unique_ptr.hpp>
+#include <autoware/cuda_utils/stream_unique_ptr.hpp>
 #include <opencv2/opencv.hpp>
 
 #include <memory>
@@ -27,10 +27,10 @@
 
 namespace autoware::tensorrt_classifier
 {
-using cuda_utils::CudaUniquePtr;
-using cuda_utils::CudaUniquePtrHost;
-using cuda_utils::makeCudaStream;
-using cuda_utils::StreamUniquePtr;
+using autoware::cuda_utils::CudaUniquePtr;
+using autoware::cuda_utils::CudaUniquePtrHost;
+using autoware::cuda_utils::makeCudaStream;
+using autoware::cuda_utils::StreamUniquePtr;
 
 /**
  * @class TrtClassifier

perception/autoware_tensorrt_classifier/package.xml

@@ -20,7 +20,7 @@
   <build_depend>autoware_cmake</build_depend>
 
   <depend>autoware_tensorrt_common</depend>
-  <depend>cuda_utils</depend>
+  <depend>autoware_cuda_utils</depend>
   <depend>libopencv-dev</depend>
   <depend>rclcpp</depend>
 

perception/autoware_tensorrt_classifier/src/tensorrt_classifier.cpp

@@ -170,13 +170,13 @@ TrtClassifier::TrtClassifier(
     std::accumulate(input_dims.d + 1, input_dims.d + input_dims.nbDims, 1, std::multiplies<int>());
 
   const auto output_dims = trt_common_->getBindingDimensions(1);
-  input_d_ = cuda_utils::make_unique<float[]>(batch_config[2] * input_size);
+  input_d_ = autoware::cuda_utils::make_unique<float[]>(batch_config[2] * input_size);
   out_elem_num_ = std::accumulate(
     output_dims.d + 1, output_dims.d + output_dims.nbDims, 1, std::multiplies<int>());
   out_elem_num_ = out_elem_num_ * batch_config[2];
   out_elem_num_per_batch_ = static_cast<int>(out_elem_num_ / batch_config[2]);
-  out_prob_d_ = cuda_utils::make_unique<float[]>(out_elem_num_);
-  out_prob_h_ = cuda_utils::make_unique_host<float[]>(out_elem_num_, cudaHostAllocPortable);
+  out_prob_d_ = autoware::cuda_utils::make_unique<float[]>(out_elem_num_);
+  out_prob_h_ = autoware::cuda_utils::make_unique_host<float[]>(out_elem_num_, cudaHostAllocPortable);
 
   if (cuda) {
     m_cuda = true;

perception/autoware_tensorrt_yolox/include/autoware/tensorrt_yolox/calibrator.hpp

@@ -37,8 +37,8 @@
 #ifndef AUTOWARE__TENSORRT_YOLOX__CALIBRATOR_HPP_
 #define AUTOWARE__TENSORRT_YOLOX__CALIBRATOR_HPP_
 
-#include "cuda_utils/cuda_check_error.hpp"
-#include "cuda_utils/cuda_unique_ptr.hpp"
+#include "autoware/cuda_utils/cuda_check_error.hpp"
+#include "autoware/cuda_utils/cuda_unique_ptr.hpp"
 
 #include <opencv2/core/core.hpp>
 #include <opencv2/highgui/highgui.hpp>

perception/autoware_tensorrt_yolox/include/autoware/tensorrt_yolox/tensorrt_yolox.hpp

@@ -17,8 +17,8 @@
 
 #include <autoware/tensorrt_common/tensorrt_common.hpp>
 #include <autoware/tensorrt_yolox/preprocess.hpp>
-#include <cuda_utils/cuda_unique_ptr.hpp>
-#include <cuda_utils/stream_unique_ptr.hpp>
+#include <autoware/cuda_utils/cuda_unique_ptr.hpp>
+#include <autoware/cuda_utils/stream_unique_ptr.hpp>
 #include <opencv2/opencv.hpp>
 
 #include <memory>
@@ -27,10 +27,10 @@
 
 namespace autoware::tensorrt_yolox
 {
-using cuda_utils::CudaUniquePtr;
-using cuda_utils::CudaUniquePtrHost;
-using cuda_utils::makeCudaStream;
-using cuda_utils::StreamUniquePtr;
+using autoware::cuda_utils::CudaUniquePtr;
+using autoware::cuda_utils::CudaUniquePtrHost;
+using autoware::cuda_utils::makeCudaStream;
+using autoware::cuda_utils::StreamUniquePtr;
 
 struct Object
 {

perception/autoware_tensorrt_yolox/package.xml

@@ -22,7 +22,7 @@
   <depend>autoware_object_recognition_utils</depend>
   <depend>autoware_perception_msgs</depend>
   <depend>autoware_tensorrt_common</depend>
-  <depend>cuda_utils</depend>
+  <depend>autoware_cuda_utils</depend>
   <depend>cv_bridge</depend>
   <depend>image_transport</depend>
   <depend>libopencv-dev</depend>