DeviceHashBackend.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// -                        CloudViewer: www.cloudViewer.org                  -
// ----------------------------------------------------------------------------
// Copyright (c) 2018-2024 www.cloudViewer.org
// SPDX-License-Identifier: MIT
// ----------------------------------------------------------------------------
 
#pragma once
 
#include "cloudViewer/core/CUDAUtils.h"
#include "cloudViewer/core/MemoryManager.h"
#include "cloudViewer/core/Tensor.h"
#include "cloudViewer/core/hashmap/HashBackendBuffer.h"
 
namespace cloudViewer {
namespace core {
 
enum class HashBackendType;
 
class DeviceHashBackend {
public:
    DeviceHashBackend(int64_t init_capacity,
                      int64_t key_dsize,
                      const std::vector<int64_t>& value_dsizes,
                      const Device& device)
        : capacity_(init_capacity),
          key_dsize_(key_dsize),
          value_dsizes_(value_dsizes),
          device_(device) {}
    virtual ~DeviceHashBackend() {}
 
    virtual void Reserve(int64_t capacity) = 0;
 
    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;
 
    virtual void Find(const void* input_keys,
                      buf_index_t* output_buf_indices,
                      bool* output_masks,
                      int64_t count) = 0;
 
    virtual void Erase(const void* input_keys,
                       bool* output_masks,
                       int64_t count) = 0;
 
    virtual int64_t GetActiveIndices(buf_index_t* output_buf_indices) = 0;
 
    virtual void Clear() = 0;
 
    virtual int64_t Size() const = 0;
 
    virtual int64_t GetBucketCount() const = 0;
 
    virtual float LoadFactor() const = 0;
 
    int64_t GetCapacity() const { return capacity_; }
 
    Device GetDevice() const { return device_; }
 
    virtual std::vector<int64_t> BucketSizes() const = 0;
 
    Tensor GetKeyBuffer() { return buffer_->GetKeyBuffer(); }
 
    std::vector<Tensor> GetValueBuffers() { return buffer_->GetValueBuffers(); }
 
    Tensor GetValueBuffer(size_t i = 0) { return buffer_->GetValueBuffer(i); }
 
    virtual void Allocate(int64_t capacity) = 0;
    virtual void Free() = 0;
 
public:
    int64_t capacity_;
 
    int64_t key_dsize_;
    std::vector<int64_t> value_dsizes_;
 
    Device device_;
 
    std::shared_ptr<HashBackendBuffer> buffer_;
};
 
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);
 
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);
 
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);
 
}  // namespace core
}  // namespace cloudViewer