Buffer.h

// ======================================================================== //
// Copyright 2019-2021 Ingo Wald                                            //
//                                                                          //
// Licensed under the Apache License, Version 2.0 (the "License");          //
// you may not use this file except in compliance with the License.         //
// You may obtain a copy of the License at                                  //
//                                                                          //
//     http://www.apache.org/licenses/LICENSE-2.0                           //
//                                                                          //
// Unless required by applicable law or agreed to in writing, software      //
// distributed under the License is distributed on an "AS IS" BASIS,        //
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. //
// See the License for the specific language governing permissions and      //
// limitations under the License.                                           //
// ======================================================================== //
 
#pragma once
 
#include "RegisteredObject.h"
#include "Texture.h"
 
namespace owl {
 
  struct Group;
  
  struct Buffer : public RegisteredObject
  {
    typedef std::shared_ptr<Buffer> SP;
    
    struct DeviceData : public RegisteredObject::DeviceData {
      typedef std::shared_ptr<DeviceData> SP;
 
      DeviceData(const DeviceContext::SP &device);
 
      void *d_pointer { 0 };
    };
 
    Buffer(Context *const context, OWLDataType type);
    
    virtual ~Buffer();
    
    std::string toString() const override;
 
    inline Buffer::DeviceData &getDD(const DeviceContext::SP &device) const;
 
    inline const void *getPointer(const DeviceContext::SP &device) const;
 
    inline size_t getElementCount() const;
 
    inline size_t sizeInBytes() const { return elementCount * sizeOf(type); }
    
    virtual void clear() = 0;
    
    virtual void resize(size_t newElementCount) = 0;
    
    virtual void upload(const void *hostPtr, size_t offset, int64_t count) = 0;
 
    virtual void upload(const int deviceID, const void *hostPtr, size_t offset, int64_t count) = 0;
 
    RegisteredObject::DeviceData::SP createOn(const DeviceContext::SP &device) override;
 
    void destroy();
 
    const OWLDataType type;
 
    size_t      elementCount { 0 };
  };
 
 
 
  struct DeviceBuffer : public Buffer {
    typedef std::shared_ptr<DeviceBuffer> SP;
 
    struct DeviceData : public Buffer::DeviceData {
      typedef std::shared_ptr<DeviceData> SP;
 
      DeviceData(DeviceBuffer *parent, const DeviceContext::SP &device);
 
      virtual ~DeviceData();
 
      virtual void executeResize() = 0;
      
      virtual void uploadAsync(const void *hostDataPtr, size_t offset, int64_t count) = 0;
      
      virtual void clear() = 0;
    
      DeviceBuffer *const parent;
    };
 
    
    struct DeviceDataForTextures : public DeviceData {
      DeviceDataForTextures(DeviceBuffer *parent, const DeviceContext::SP &device)
        : DeviceData(parent,device)
      {}
      void executeResize() override;
      void uploadAsync(const void *hostDataPtr, size_t offset, int64_t count) override;
      
      void clear() override;
    
      std::vector<Texture::SP> hostHandles;
    };
 
 
 
    struct DeviceDataForBuffers : public DeviceData {
      DeviceDataForBuffers(DeviceBuffer *parent, const DeviceContext::SP &device)
        : DeviceData(parent,device)
      {}
      
      void executeResize() override;
      void uploadAsync(const void *hostDataPtr, size_t offset, int64_t count) override;
      
      void clear() override;
    
      std::vector<Buffer::SP> hostHandles;
    };
 
 
    struct DeviceDataForGroups : public DeviceData {
      DeviceDataForGroups(DeviceBuffer *parent, const DeviceContext::SP &device)
        : DeviceData(parent,device)
      {}
      
      void executeResize() override;
      void uploadAsync(const void *hostDataPtr, size_t offset, int64_t count) override;
      
      void clear() override;
      
      std::vector<std::shared_ptr<Group>> hostHandles;
    };
 
 
    
    struct DeviceDataForCopyableData : public DeviceData {
      DeviceDataForCopyableData(DeviceBuffer *parent, const DeviceContext::SP &device)
        : DeviceData(parent,device)
      {}
      void executeResize() override;
      void uploadAsync(const void *hostDataPtr, size_t offset, int64_t count) override;
      
      void clear() override;
    };
 
    DeviceBuffer(Context *const context,
                 OWLDataType type);
 
    std::string toString() const override;
 
    inline DeviceData &getDD(const DeviceContext::SP &device) const;
 
    void resize(size_t newElementCount) override;
    void upload(const void *hostPtr, size_t offset, int64_t count) override;
    
    void upload(const int deviceID, const void *hostPtr, size_t offset, int64_t count) override;
      
    void clear() override;
    
    RegisteredObject::DeviceData::SP createOn(const DeviceContext::SP &device) override;
  };
 
 
  struct HostPinnedBuffer : public Buffer {
    typedef std::shared_ptr<HostPinnedBuffer> SP;
    
    HostPinnedBuffer(Context *const context,
                     OWLDataType type);
    
    virtual ~HostPinnedBuffer();
 
    std::string toString() const override;
 
    void resize(size_t newElementCount) override;
    void upload(const void *hostPtr, size_t offset, int64_t count) override;
    void upload(const int deviceID, const void *hostPtr, size_t offset, int64_t count) override;
      
    void clear() override;
 
    void *cudaHostPinnedMem { 0 };
  };
 
 
  
  struct ManagedMemoryBuffer : public Buffer {
    typedef std::shared_ptr<ManagedMemoryBuffer> SP;
    
    ManagedMemoryBuffer(Context *const context,
                        OWLDataType type);
    
    virtual ~ManagedMemoryBuffer();
 
    void resize(size_t newElementCount) override;
    void upload(const void *hostPtr, size_t offset, int64_t count) override;
    void upload(const int deviceID, const void *hostPtr, size_t offset, int64_t count) override;
 
    std::string toString() const override;
      
    void clear() override;
 
    void *cudaManagedMem { 0 };
  };
 
 
  struct GraphicsBuffer : public Buffer {
    typedef std::shared_ptr<GraphicsBuffer> SP;
 
    GraphicsBuffer(Context* const context,
                   OWLDataType type,
                   cudaGraphicsResource_t resource);
 
    void map(const int deviceID=0, CUstream stream=0);
    void unmap(const int deviceID=0, CUstream stream=0);
 
    void resize(size_t newElementCount) override;
    void upload(const void *hostPtr, size_t offset, int64_t count) override;
    void upload(const int deviceID, const void *hostPtr, size_t offset, int64_t count) override;
      
    void clear() override;
 
    cudaGraphicsResource_t resource;
    
    std::string toString() const override;
  };
 
 
 
  // ------------------------------------------------------------------
  // implementation section
  // ------------------------------------------------------------------
  
  
  inline size_t Buffer::getElementCount() const
  {
    return elementCount;
  }
  
  const void *Buffer::getPointer(const DeviceContext::SP &device) const
  {
    assert(device);
    return getDD(device).d_pointer;
  }
  
  inline Buffer::DeviceData &Buffer::getDD(const DeviceContext::SP &device) const
  {
    assert(device && device->ID >= 0 && device->ID < (int)deviceData.size());
    return deviceData[device->ID]->as<Buffer::DeviceData>();
  }
  
  inline DeviceBuffer::DeviceData &DeviceBuffer::getDD(const DeviceContext::SP &device) const
  {
    assert(device && device->ID >= 0 && device->ID < (int)deviceData.size());
    return deviceData[device->ID]->as<DeviceData>();
  }
 
} // ::owl