MemoryManager.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 <cstring>
#include <memory>
#include <stdexcept>
#include <string>
#include <unordered_map>
 
#include "cloudViewer/core/Device.h"
 
namespace cloudViewer {
namespace core {
 
class MemoryManagerDevice;
 
class MemoryManager {
public:
    static void* Malloc(size_t byte_size, const Device& device);
 
    static void Free(void* ptr, const Device& device);
 
    static void Memcpy(void* dst_ptr,
                       const Device& dst_device,
                       const void* src_ptr,
                       const Device& src_device,
                       size_t num_bytes);
 
    static void MemcpyFromHost(void* dst_ptr,
                               const Device& dst_device,
                               const void* host_ptr,
                               size_t num_bytes);
 
    static void MemcpyToHost(void* host_ptr,
                             const void* src_ptr,
                             const Device& src_device,
                             size_t num_bytes);
 
protected:
    static std::shared_ptr<MemoryManagerDevice> GetMemoryManagerDevice(
            const Device& device);
};
 
class MemoryManagerDevice {
public:
    virtual ~MemoryManagerDevice() = default;
 
    virtual void* Malloc(size_t byte_size, const Device& device) = 0;
 
    virtual void Free(void* ptr, const Device& device) = 0;
 
    virtual void Memcpy(void* dst_ptr,
                        const Device& dst_device,
                        const void* src_ptr,
                        const Device& src_device,
                        size_t num_bytes) = 0;
};
 
class MemoryManagerCached : public MemoryManagerDevice {
public:
    explicit MemoryManagerCached(
            const std::shared_ptr<MemoryManagerDevice>& device_mm);
 
    void* Malloc(size_t byte_size, const Device& device) override;
 
    void Free(void* ptr, const Device& device) override;
 
    void Memcpy(void* dst_ptr,
                const Device& dst_device,
                const void* src_ptr,
                const Device& src_device,
                size_t num_bytes) override;
 
public:
    static void ReleaseCache(const Device& device);
 
    static void ReleaseCache();
 
protected:
    std::shared_ptr<MemoryManagerDevice> device_mm_;
};
 
class MemoryManagerCPU : public MemoryManagerDevice {
public:
    void* Malloc(size_t byte_size, const Device& device) override;
 
    void Free(void* ptr, const Device& device) override;
 
    void Memcpy(void* dst_ptr,
                const Device& dst_device,
                const void* src_ptr,
                const Device& src_device,
                size_t num_bytes) override;
};
 
#ifdef BUILD_CUDA_MODULE
class MemoryManagerCUDA : public MemoryManagerDevice {
public:
    void* Malloc(size_t byte_size, const Device& device) override;
 
    void Free(void* ptr, const Device& device) override;
 
    void Memcpy(void* dst_ptr,
                const Device& dst_device,
                const void* src_ptr,
                const Device& src_device,
                size_t num_bytes) override;
 
protected:
    bool IsCUDAPointer(const void* ptr, const Device& device);
};
#endif
 
#ifdef BUILD_SYCL_MODULE
class MemoryManagerSYCL : public MemoryManagerDevice {
public:
    void* Malloc(size_t byte_size, const Device& device) override;
 
    void Free(void* ptr, const Device& device) override;
 
    void Memcpy(void* dst_ptr,
                const Device& dst_device,
                const void* src_ptr,
                const Device& src_device,
                size_t num_bytes) override;
};
#endif
 
}  // namespace core
}  // namespace cloudViewer