Open3D (C++ API)  0.18.0
DeviceHashBackend.h
Go to the documentation of this file.
1 // ----------------------------------------------------------------------------
2 // - Open3D: www.open3d.org -
3 // ----------------------------------------------------------------------------
4 // Copyright (c) 2018-2023 www.open3d.org
5 // SPDX-License-Identifier: MIT
6 // ----------------------------------------------------------------------------
7 
8 #pragma once
9 
10 #include "open3d/core/CUDAUtils.h"
12 #include "open3d/core/Tensor.h"
14 
15 namespace open3d {
16 namespace core {
17 
18 enum class HashBackendType;
19 
21 public:
22  DeviceHashBackend(int64_t init_capacity,
23  int64_t key_dsize,
24  const std::vector<int64_t>& value_dsizes,
25  const Device& device)
26  : capacity_(init_capacity),
27  key_dsize_(key_dsize),
28  value_dsizes_(value_dsizes),
29  device_(device) {}
30  virtual ~DeviceHashBackend() {}
31 
38  virtual void Reserve(int64_t capacity) = 0;
39 
41  virtual void Insert(const void* input_keys,
42  const std::vector<const void*>& input_values,
43  buf_index_t* output_buf_indices,
44  bool* output_masks,
45  int64_t count) = 0;
46 
48  virtual void Find(const void* input_keys,
49  buf_index_t* output_buf_indices,
50  bool* output_masks,
51  int64_t count) = 0;
52 
54  virtual void Erase(const void* input_keys,
55  bool* output_masks,
56  int64_t count) = 0;
57 
59  virtual int64_t GetActiveIndices(buf_index_t* output_buf_indices) = 0;
60 
62  virtual void Clear() = 0;
63 
65  virtual int64_t Size() const = 0;
66 
68  virtual int64_t GetBucketCount() const = 0;
69 
71  virtual float LoadFactor() const = 0;
72 
74  int64_t GetCapacity() const { return capacity_; }
75 
77  Device GetDevice() const { return device_; }
78 
80  virtual std::vector<int64_t> BucketSizes() const = 0;
81 
83  Tensor GetKeyBuffer() { return buffer_->GetKeyBuffer(); }
84 
86  std::vector<Tensor> GetValueBuffers() { return buffer_->GetValueBuffers(); }
87 
89  Tensor GetValueBuffer(size_t i = 0) { return buffer_->GetValueBuffer(i); }
90 
91  virtual void Allocate(int64_t capacity) = 0;
92  virtual void Free() = 0;
93 
94 public:
95  int64_t capacity_;
96 
97  int64_t key_dsize_;
98  std::vector<int64_t> value_dsizes_;
99 
101 
102  std::shared_ptr<HashBackendBuffer> buffer_;
103 };
104 
109 std::shared_ptr<DeviceHashBackend> CreateDeviceHashBackend(
110  int64_t init_capacity,
111  const Dtype& key_dtype,
112  const SizeVector& key_element_shape,
113  const std::vector<Dtype>& value_dtypes,
114  const std::vector<SizeVector>& value_element_shapes,
115  const Device& device,
116  const HashBackendType& backend);
117 
118 std::shared_ptr<DeviceHashBackend> CreateCPUHashBackend(
119  int64_t init_capacity,
120  const Dtype& key_dtype,
121  const SizeVector& key_element_shape,
122  const std::vector<Dtype>& value_dtypes,
123  const std::vector<SizeVector>& value_element_shapes,
124  const Device& device,
125  const HashBackendType& backend);
126 
127 std::shared_ptr<DeviceHashBackend> CreateCUDAHashBackend(
128  int64_t init_capacity,
129  const Dtype& key_dtype,
130  const SizeVector& key_element_shape,
131  const std::vector<Dtype>& value_dtypes,
132  const std::vector<SizeVector>& value_element_shapes,
133  const Device& device,
134  const HashBackendType& backend);
135 
136 } // namespace core
137 } // namespace open3d
Common CUDA utilities.
Definition: DeviceHashBackend.h:20
virtual void Insert(const void *input_keys, const std::vector< const void * > &input_values, buf_index_t *output_buf_indices, bool *output_masks, int64_t count)=0
Parallel insert contiguous arrays of keys and values.
int64_t GetCapacity() const
Get the maximum capacity of the hash map.
Definition: DeviceHashBackend.h:74
virtual void Erase(const void *input_keys, bool *output_masks, int64_t count)=0
Parallel erase a contiguous array of keys.
virtual void Allocate(int64_t capacity)=0
virtual void Clear()=0
Clear stored map without reallocating memory.
Device GetDevice() const
Get the current device.
Definition: DeviceHashBackend.h:77
std::vector< Tensor > GetValueBuffers()
Get the value buffers that store actual array of values.
Definition: DeviceHashBackend.h:86
std::vector< int64_t > value_dsizes_
Definition: DeviceHashBackend.h:98
std::shared_ptr< HashBackendBuffer > buffer_
Definition: DeviceHashBackend.h:102
Device device_
Definition: DeviceHashBackend.h:100
int64_t key_dsize_
Definition: DeviceHashBackend.h:97
Tensor GetValueBuffer(size_t i=0)
Get the i-th value buffer that store an actual value array.
Definition: DeviceHashBackend.h:89
Tensor GetKeyBuffer()
Get the key buffer that stores actual keys.
Definition: DeviceHashBackend.h:83
virtual void Reserve(int64_t capacity)=0
int64_t capacity_
Definition: DeviceHashBackend.h:95
virtual ~DeviceHashBackend()
Definition: DeviceHashBackend.h:30
virtual std::vector< int64_t > BucketSizes() const =0
Get the number of entries per bucket.
virtual int64_t GetBucketCount() const =0
Get the number of buckets of the hash map.
virtual int64_t GetActiveIndices(buf_index_t *output_buf_indices)=0
Parallel collect all iterators in the hash table.
virtual float LoadFactor() const =0
Get the current load factor, defined as size / bucket count.
virtual void Find(const void *input_keys, buf_index_t *output_buf_indices, bool *output_masks, int64_t count)=0
Parallel find a contiguous array of keys.
DeviceHashBackend(int64_t init_capacity, int64_t key_dsize, const std::vector< int64_t > &value_dsizes, const Device &device)
Definition: DeviceHashBackend.h:22
virtual int64_t Size() const =0
Get the size (number of valid entries) of the hash map.
Definition: Device.h:18
Definition: Dtype.h:20
Definition: SizeVector.h:69
Definition: Tensor.h:32
int count
Definition: FilePCD.cpp:42
std::shared_ptr< DeviceHashBackend > CreateCPUHashBackend(int64_t init_capacity, const Dtype &key_dtype, const SizeVector &key_element_shape, const std::vector< Dtype > &value_dtypes, const std::vector< SizeVector > &value_element_shapes, const Device &device, const HashBackendType &backend)
Non-templated factory.
Definition: CreateCPUHashBackend.cpp:16
uint32_t buf_index_t
Definition: HashBackendBuffer.h:44
std::shared_ptr< DeviceHashBackend > CreateCUDAHashBackend(int64_t init_capacity, const Dtype &key_dtype, const SizeVector &key_element_shape, const std::vector< Dtype > &value_dtypes, const std::vector< SizeVector > &value_element_shapes, const Device &device, const HashBackendType &backend)
std::shared_ptr< DeviceHashBackend > CreateDeviceHashBackend(int64_t init_capacity, const Dtype &key_dtype, const SizeVector &key_element_shape, const std::vector< Dtype > &value_dtypes, const std::vector< SizeVector > &value_element_shapes, const Device &device, const HashBackendType &backend)
Definition: DeviceHashBackend.cpp:17
HashBackendType
Definition: HashMap.h:20
Definition: PinholeCameraIntrinsic.cpp:16