DeviceContext.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 "owl/owl.h"
#include "owl/common.h"
#include "owl/DeviceMemory.h"
#include "owl/helper/optix.h"
 
namespace owl {
 
  struct RangeAllocator {
    int alloc(size_t size);
    void release(size_t begin, size_t size);
    size_t maxAllocedID = 0;
  private:
    struct FreedRange {
      size_t begin;
      size_t size;
    };
    std::vector<FreedRange> freedRanges;
  };
 
  struct SBT {
    size_t rayGenRecordCount   = 0;
    size_t rayGenRecordSize    = 0;
    DeviceMemory rayGenRecordsBuffer;
 
    size_t hitGroupRecordSize  = 0;
    size_t hitGroupRecordCount = 0;
    DeviceMemory hitGroupRecordsBuffer;
 
    size_t missProgRecordSize  = 0;
    size_t missProgRecordCount = 0;
    DeviceMemory missProgRecordsBuffer;
    
    DeviceMemory launchParamsBuffer;
  };
 
  struct Context;
 
  struct DeviceContext : public std::enable_shared_from_this<DeviceContext>  {
    typedef std::shared_ptr<DeviceContext> SP;
 
    DeviceContext(Context *parent,
                  int owlID,
                  int cudaID);
    ~DeviceContext();
    
    std::string getDeviceName() const;
      
    int getCudaDeviceID() const;
 
    CUstream getStream() const { return stream; }
 
    void configurePipelineOptions(bool debug = false);
      
    void buildPrograms();
    void buildMissPrograms();
    void buildRayGenPrograms();
    void buildHitGroupPrograms();
 
    void destroyPrograms();
    void destroyMissPrograms();
    void destroyRayGenPrograms();
    void destroyHitGroupPrograms();
 
    void destroyPipeline();
    void buildPipeline();
 
    void buildCurvesModules();
    void buildSphereModule();
    
    std::vector<OptixProgramGroup> allActivePrograms;
 
    OptixDeviceContext optixContext = nullptr;
    CUcontext          cudaContext  = nullptr;
    CUstream           stream       = nullptr;
 
    OptixPipelineCompileOptions pipelineCompileOptions = {};
    OptixPipelineLinkOptions    pipelineLinkOptions    = {};
    OptixModuleCompileOptions   moduleCompileOptions   = {};
    OptixPipeline               pipeline               = nullptr;
    SBT                         sbt                    = {};
    
    OptixModule                 curvesModule[2][3]
    = {
       { nullptr, nullptr, nullptr },
       { nullptr, nullptr, nullptr }
    };
    
    OptixModule                 spheresModule = nullptr;
 
    Context *const parent;
 
    const int      ID;
 
    /* the cuda device ID that this logical device runs on */
    const int      cudaDeviceID;
  };
 
  std::vector<DeviceContext::SP> createDeviceContexts(Context *parent,
                                                      int32_t *requestedDeviceIDs,
                                                      int      numRequestedDevices);
 
  struct SetActiveGPU {
    inline SetActiveGPU(const DeviceContext::SP &device)
    {
      OWL_CUDA_CHECK(cudaGetDevice(&savedActiveDeviceID));
      OWL_CUDA_CHECK(cudaSetDevice(device->cudaDeviceID));
    }
    inline SetActiveGPU(const DeviceContext *device)
    {
      OWL_CUDA_CHECK(cudaGetDevice(&savedActiveDeviceID));
      OWL_CUDA_CHECK(cudaSetDevice(device->cudaDeviceID));
    }
    inline ~SetActiveGPU()
    {
      OWL_CUDA_CHECK_NOTHROW(cudaSetDevice(savedActiveDeviceID));
    }
  private:
    int savedActiveDeviceID = -1;
  };
  
} // ::owl