HashMap.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/Device.h"
#include "cloudViewer/core/Dtype.h"
#include "cloudViewer/core/Tensor.h"
#include "cloudViewer/core/hashmap/DeviceHashBackend.h"
#include "cloudViewer/core/hashmap/HashBackendBuffer.h"
 
namespace cloudViewer {
namespace core {
 
class DeviceHashBackend;
 
enum class HashBackendType { Slab, StdGPU, TBB, Default };
 
class HashMap : public IsDevice {
public:
    HashMap(int64_t init_capacity,
            const Dtype& key_dtype,
            const SizeVector& key_element_shape,
            const Dtype& value_dtype,
            const SizeVector& value_element_shapes,
            const Device& device,
            const HashBackendType& backend = HashBackendType::Default);
 
    HashMap(int64_t init_capacity,
            const Dtype& key_dtype,
            const SizeVector& key_element_shape,
            const std::vector<Dtype>& dtypes_value,
            const std::vector<SizeVector>& element_shapes_value,
            const Device& device,
            const HashBackendType& backend = HashBackendType::Default);
 
    ~HashMap() = default;
 
    void Reserve(int64_t capacity);
 
    std::pair<Tensor, Tensor> Insert(const Tensor& input_keys,
                                     const Tensor& input_values);
 
    std::pair<Tensor, Tensor> Insert(
            const Tensor& input_keys,
            const std::vector<Tensor>& input_values_soa);
 
    std::pair<Tensor, Tensor> Activate(const Tensor& input_keys);
 
    std::pair<Tensor, Tensor> Find(const Tensor& input_keys);
 
    Tensor Erase(const Tensor& input_keys);
 
    Tensor GetActiveIndices() const;
 
    void Insert(const Tensor& input_keys,
                const Tensor& input_values,
                Tensor& output_buf_indices,
                Tensor& output_masks);
 
    void Insert(const Tensor& input_keys,
                const std::vector<Tensor>& input_values_soa,
                Tensor& output_buf_indices,
                Tensor& output_masks);
 
    void Activate(const Tensor& input_keys,
                  Tensor& output_buf_indices,
                  Tensor& output_masks);
 
    void Find(const Tensor& input_keys,
              Tensor& output_buf_indices,
              Tensor& output_masks);
 
    void Erase(const Tensor& input_keys, Tensor& output_masks);
 
    void GetActiveIndices(Tensor& output_buf_indices) const;
 
    void Clear();
 
    void Save(const std::string& file_name);
 
    static HashMap Load(const std::string& file_name);
 
    HashMap Clone() const;
 
    HashMap To(const Device& device, bool copy = false) const;
 
    int64_t Size() const;
 
    int64_t GetCapacity() const;
 
    int64_t GetBucketCount() const;
 
    Device GetDevice() const override;
 
    Tensor GetKeyTensor() const;
 
    std::vector<Tensor> GetValueTensors() const;
 
    Tensor GetValueTensor(size_t index = 0) const;
 
    std::vector<int64_t> BucketSizes() const;
 
    float LoadFactor() const;
 
    std::shared_ptr<DeviceHashBackend> GetDeviceHashBackend() const {
        return device_hashmap_;
    }
 
protected:
    void Init(int64_t init_capacity,
              const Device& device,
              const HashBackendType& backend);
 
    void InsertImpl(const Tensor& input_keys,
                    const std::vector<Tensor>& input_values_soa,
                    Tensor& output_buf_indices,
                    Tensor& output_masks,
                    bool is_activate_op = false);
 
    void CheckKeyLength(const Tensor& input_keys) const;
    void CheckKeyValueLengthCompatibility(
            const Tensor& input_keys,
            const std::vector<Tensor>& input_values_soa) const;
    void CheckKeyCompatibility(const Tensor& input_keys) const;
    void CheckValueCompatibility(
            const std::vector<Tensor>& input_values_soa) const;
 
    void PrepareIndicesOutput(Tensor& output_buf_indices, int64_t length) const;
    void PrepareMasksOutput(Tensor& output_masks, int64_t length) const;
 
    std::pair<int64_t, std::vector<int64_t>> GetCommonValueSizeDivisor();
 
private:
    std::shared_ptr<DeviceHashBackend> device_hashmap_;
 
    Dtype key_dtype_;
    SizeVector key_element_shape_;
 
    std::vector<Dtype> dtypes_value_;
    std::vector<SizeVector> element_shapes_value_;
};
 
}  // namespace core
}  // namespace cloudViewer