offloadable

Author: koide3

include/gtsam_points/types/offloadable.hpp

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <vector>
+#include <atomic>
+#include <cstdint>
+
+// forward declaration
+struct CUstream_st;
+
+namespace gtsam_points {
+
+/**
+ * @brief An interface class for offloading data on the GPU memory.
+ */
+class OffloadableGPU {
+public:
+  OffloadableGPU();
+  virtual ~OffloadableGPU();
+
+  // GPU memory offloading
+  static std::uint64_t current_access_time();
+  std::uint64_t last_accessed_time() const;
+
+  virtual size_t memory_usage_gpu() const { return 0; }
+
+  virtual bool touch(CUstream_st* stream = 0) = 0;
+  virtual bool offload_gpu(CUstream_st* stream = 0) = 0;
+  virtual bool reload_gpu(CUstream_st* stream = 0) = 0;
+
+private:
+  static std::atomic_uint64_t access_counter;  ///< Counter for the last access time
+  std::uint64_t last_access;
+};
+
+}  // namespace gtsam_points

include/gtsam_points/types/point_cloud.hpp

@@ -99,16 +99,6 @@ struct PointCloud {
    */
   void save_compact(const std::string& path) const;
 
-  /**
-   * @brief Calculate the CPU memory usage of this point cloud
-   */
-  size_t memory_usage() const;
-
-  /**
-   * @brief Calculate the GPU memory usage of this point cloud
-   */
-  size_t memory_usage_gpu() const;
-
 public:
   size_t num_points;  ///< Number of points
 

include/gtsam_points/types/point_cloud_gpu.hpp

@@ -9,6 +9,7 @@
 
 #include <gtsam_points/types/point_cloud.hpp>
 #include <gtsam_points/types/point_cloud_cpu.hpp>
+#include <gtsam_points/types/offloadable.hpp>
 
 // forward declaration
 struct CUstream_st;
@@ -18,7 +19,7 @@ namespace gtsam_points {
 /**
  * @brief Point cloud frame on GPU memory
  */
-struct PointCloudGPU : public PointCloudCPU {
+struct PointCloudGPU : public PointCloudCPU, public OffloadableGPU {
 public:
   using Ptr = std::shared_ptr<PointCloudGPU>;
   using ConstPtr = std::shared_ptr<const PointCloudGPU>;
@@ -128,16 +129,10 @@ struct PointCloudGPU : public PointCloudCPU {
   void download_points(CUstream_st* stream = 0);
 
   // GPU memory offloading
-  static std::uint64_t current_access_time() { return access_time_counter.load(); }
-  std::uint64_t last_accessed_time() const { return last_access; }
+  virtual size_t memory_usage_gpu() const override;
 
-  bool touch(CUstream_st* stream = 0);
   bool offload_gpu(CUstream_st* stream = 0);
   bool reload_gpu(CUstream_st* stream = 0);
-
-private:
-  static std::atomic_uint64_t access_time_counter;
-  std::uint64_t last_access;
 };
 
 // Device to host data transfer

src/gtsam_points/types/offloadable.cpp

@@ -0,0 +1,25 @@
+#include <gtsam_points/types/offloadable.hpp>
+
+namespace gtsam_points {
+
+std::atomic_uint64_t OffloadableGPU::access_counter(0);  ///< Counter for the last access time
+
+OffloadableGPU::OffloadableGPU() : last_access(0) {}
+
+OffloadableGPU::~OffloadableGPU() {}
+
+// GPU memory offloading
+std::uint64_t OffloadableGPU::current_access_time() {
+  return access_counter.load();
+}
+
+std::uint64_t OffloadableGPU::last_accessed_time() const {
+  return last_access;
+}
+
+bool OffloadableGPU::touch(CUstream_st* stream) {
+  last_access = (access_counter++);
+  return reload_gpu(stream);
+}
+
+}  // namespace gtsam_points

src/gtsam_points/types/point_cloud.cpp

@@ -202,47 +202,4 @@ void PointCloud::save_compact(const std::string& path) const {
   }
 }
 
-size_t PointCloud::memory_usage() const {
-  size_t bytes = 0;
-  if (times) {
-    bytes += sizeof(double) * num_points;
-  }
-  if (points) {
-    bytes += sizeof(Eigen::Vector4d) * num_points;
-  }
-  if (normals) {
-    bytes += sizeof(Eigen::Vector4d) * num_points;
-  }
-  if (covs) {
-    bytes += sizeof(Eigen::Matrix4d) * num_points;
-  }
-  if (intensities) {
-    bytes += sizeof(double) * num_points;
-  }
-  for (const auto& attrib : aux_attributes) {
-    bytes += attrib.second.first * num_points;  // size of each element * number of points
-  }
-  return bytes;
-}
-
-size_t PointCloud::memory_usage_gpu() const {
-  size_t bytes = 0;
-  if (times_gpu) {
-    bytes += sizeof(float) * num_points;
-  }
-  if (points_gpu) {
-    bytes += sizeof(Eigen::Vector3f) * num_points;
-  }
-  if (normals_gpu) {
-    bytes += sizeof(Eigen::Vector3f) * num_points;
-  }
-  if (covs_gpu) {
-    bytes += sizeof(Eigen::Matrix3f) * num_points;
-  }
-  if (intensities_gpu) {
-    bytes += sizeof(float) * num_points;
-  }
-  return bytes;
-}
-
 }  // namespace gtsam_points

src/gtsam_points/types/point_cloud_cpu.cpp

@@ -293,4 +293,27 @@ PointCloudCPU::Ptr PointCloudCPU::load(const std::string& path) {
   return frame;
 }
 
+size_t PointCloudCPU::memory_usage() const {
+  size_t bytes = 0;
+  if (times) {
+    bytes += sizeof(double) * num_points;
+  }
+  if (points) {
+    bytes += sizeof(Eigen::Vector4d) * num_points;
+  }
+  if (normals) {
+    bytes += sizeof(Eigen::Vector4d) * num_points;
+  }
+  if (covs) {
+    bytes += sizeof(Eigen::Matrix4d) * num_points;
+  }
+  if (intensities) {
+    bytes += sizeof(double) * num_points;
+  }
+  for (const auto& attrib : aux_attributes) {
+    bytes += attrib.second.first * num_points;  // size of each element * number of points
+  }
+  return bytes;
+}
+
 }  // namespace gtsam_points

src/gtsam_points/types/point_cloud_gpu.cu

@@ -285,6 +285,26 @@ bool PointCloudGPU::touch(CUstream_st* stream) {
   return reload_gpu(stream);
 }
 
+size_t PointCloudGPU::memory_usage_gpu() const {
+  size_t bytes = 0;
+  if (times_gpu) {
+    bytes += sizeof(float) * num_points;
+  }
+  if (points_gpu) {
+    bytes += sizeof(Eigen::Vector3f) * num_points;
+  }
+  if (normals_gpu) {
+    bytes += sizeof(Eigen::Vector3f) * num_points;
+  }
+  if (covs_gpu) {
+    bytes += sizeof(Eigen::Matrix3f) * num_points;
+  }
+  if (intensities_gpu) {
+    bytes += sizeof(float) * num_points;
+  }
+  return bytes;
+}
+
 bool PointCloudGPU::offload_gpu(CUstream_st* stream) {
   if (!points_gpu && !times_gpu && !normals_gpu && !covs_gpu && !intensities_gpu) {
     return false;  // Nothing to offload