Back to home page

EIC code displayed by LXR
 
 

    

File indexing completed on 2026-04-09 07:49:02 

0001 #pragma once
0002 
0003 #include "sstr.h"
0004 
0005 /**
0006 OPT.h
0007 ======
0008 
0009 
0010 From 800 the OPTIX_EXCEPTION_FLAG_DEBUG is removed::
0011 
0012     vimdiff OptiX_770/include/optix_types.h OptiX_800/include/optix_types.h
0013 
0014 **/
0015 
0016 struct OPT
0017 {
0018     static constexpr const bool VERBOSE = false ; 
0019 
0020     static OptixCompileDebugLevel        DebugLevel(const char* option); 
0021     static const char *                  DebugLevel_( OptixCompileDebugLevel debugLevel ); 
0022 #if OPTIX_VERSION == 70000
0023     static constexpr const char* OPTIX_COMPILE_DEBUG_LEVEL_NONE_     = "OPTIX_COMPILE_DEBUG_LEVEL_NONE" ; 
0024     static constexpr const char* OPTIX_COMPILE_DEBUG_LEVEL_LINEINFO_ = "OPTIX_COMPILE_DEBUG_LEVEL_LINEINFO" ; 
0025     static constexpr const char* OPTIX_COMPILE_DEBUG_LEVEL_FULL_     = "OPTIX_COMPILE_DEBUG_LEVEL_FULL" ; 
0026 #elif OPTIX_VERSION >= 70500
0027     static constexpr const char* OPTIX_COMPILE_DEBUG_LEVEL_DEFAULT_  = "OPTIX_COMPILE_DEBUG_LEVEL_DEFAULT" ; 
0028     static constexpr const char* OPTIX_COMPILE_DEBUG_LEVEL_NONE_     = "OPTIX_COMPILE_DEBUG_LEVEL_NONE" ; 
0029     static constexpr const char* OPTIX_COMPILE_DEBUG_LEVEL_MINIMAL_  = "OPTIX_COMPILE_DEBUG_LEVEL_MINIMAL" ; 
0030     static constexpr const char* OPTIX_COMPILE_DEBUG_LEVEL_MODERATE_ = "OPTIX_COMPILE_DEBUG_LEVEL_MODERATE" ; 
0031     static constexpr const char* OPTIX_COMPILE_DEBUG_LEVEL_FULL_     = "OPTIX_COMPILE_DEBUG_LEVEL_FULL" ; 
0032 #endif
0033 
0034 
0035 
0036 
0037     static OptixCompileOptimizationLevel OptimizationLevel(const char* option) ; 
0038     static const char* OptimizationLevel_( OptixCompileOptimizationLevel optLevel ); 
0039     static constexpr const char* OPTIX_COMPILE_OPTIMIZATION_DEFAULT_ = "OPTIX_COMPILE_OPTIMIZATION_DEFAULT" ;
0040     static constexpr const char* OPTIX_COMPILE_OPTIMIZATION_LEVEL_0_ = "OPTIX_COMPILE_OPTIMIZATION_LEVEL_0" ;
0041     static constexpr const char* OPTIX_COMPILE_OPTIMIZATION_LEVEL_1_ = "OPTIX_COMPILE_OPTIMIZATION_LEVEL_1" ;
0042     static constexpr const char* OPTIX_COMPILE_OPTIMIZATION_LEVEL_2_ = "OPTIX_COMPILE_OPTIMIZATION_LEVEL_2" ; 
0043     static constexpr const char* OPTIX_COMPILE_OPTIMIZATION_LEVEL_3_ = "OPTIX_COMPILE_OPTIMIZATION_LEVEL_3" ;
0044 
0045 
0046 
0047 
0048     static OptixExceptionFlags           ExceptionFlags_(const char* opt) ; 
0049     static const char*                   ExceptionFlags__(OptixExceptionFlags excFlag) ; 
0050     static unsigned                      ExceptionFlags(const char* options); 
0051     static std::string                   Desc_ExceptionFlags( unsigned flags ); 
0052     static constexpr const char* OPTIX_EXCEPTION_FLAG_NONE_           = "OPTIX_EXCEPTION_FLAG_NONE" ; 
0053     static constexpr const char* OPTIX_EXCEPTION_FLAG_STACK_OVERFLOW_ = "OPTIX_EXCEPTION_FLAG_STACK_OVERFLOW" ; 
0054     static constexpr const char* OPTIX_EXCEPTION_FLAG_TRACE_DEPTH_    = "OPTIX_EXCEPTION_FLAG_TRACE_DEPTH" ; 
0055     static constexpr const char* OPTIX_EXCEPTION_FLAG_USER_           = "OPTIX_EXCEPTION_FLAG_USER_" ; 
0056 #if OPTIX_VERSION <= 70700
0057     static constexpr const char* OPTIX_EXCEPTION_FLAG_DEBUG_          = "OPTIX_EXCEPTION_FLAG_DEBUG" ; 
0058 #endif
0059 
0060 
0061 
0062 };
0063 
0064 
0065 
0066 
0067 /**
0068 OPT::DebugLevel
0069 -----------------
0070 
0071 https://forums.developer.nvidia.com/t/gpu-program-optimization-questions/195238/2
0072 
0073 droettger, Nov 2021::
0074 
0075     The new OPTIX_COMPILE_DEBUG_LEVEL_MODERATE is documented to have an impact on
0076     performance.  You should use OPTIX_COMPILE_DEBUG_LEVEL_MINIMAL which keeps only
0077     the line information for profiling and OPTIX_COMPILE_DEBUG_LEVEL_NONE to remove
0078     even that.  Never profile compute kernels build as debug! That will completely
0079     change the code structure and does not represent the fully optimized code.
0080 
0081 
0082 See optix7-;optix7-types
0083 
0084 **/
0085 
0086 
0087 inline OptixCompileDebugLevel OPT::DebugLevel(const char* option)  // static
0088 {
0089     OptixCompileDebugLevel level = OPTIX_COMPILE_DEBUG_LEVEL_NONE ; 
0090 #if OPTIX_VERSION == 70000
0091     if(     strcmp(option, "NONE") == 0 )     level = OPTIX_COMPILE_DEBUG_LEVEL_NONE ; 
0092     else if(strcmp(option, "LINEINFO") == 0 ) level = OPTIX_COMPILE_DEBUG_LEVEL_LINEINFO ; 
0093     else if(strcmp(option, "FULL") == 0 )     level = OPTIX_COMPILE_DEBUG_LEVEL_FULL ; 
0094     else if(strcmp(option, "DEFAULT") == 0 )  level = OPTIX_COMPILE_DEBUG_LEVEL_NONE ; 
0095 #elif OPTIX_VERSION >= 70500
0096     if(     strcmp(option, "DEFAULT") == 0 )  level = OPTIX_COMPILE_DEBUG_LEVEL_DEFAULT ; 
0097     else if(strcmp(option, "NONE") == 0 )     level = OPTIX_COMPILE_DEBUG_LEVEL_NONE ; 
0098     else if(strcmp(option, "MINIMAL") == 0 )  level = OPTIX_COMPILE_DEBUG_LEVEL_MINIMAL ; 
0099     else if(strcmp(option, "MODERATE") == 0 ) level = OPTIX_COMPILE_DEBUG_LEVEL_MODERATE ; 
0100     else if(strcmp(option, "FULL") == 0 )     level = OPTIX_COMPILE_DEBUG_LEVEL_FULL ; 
0101 #else
0102     std::cerr 
0103         << " NOT RECOGNIZED " << " option " << option  << " level " << level  
0104         << " OPTIX_VERSION " << OPTIX_VERSION 
0105         << std::endl 
0106         ; 
0107     assert(0);   
0108 #endif
0109     if(VERBOSE) std::cout 
0110          << "OPT::DebugLevel"
0111          << " option " << option 
0112          << " level " << level 
0113          << " OPTIX_VERSION " << OPTIX_VERSION  
0114          << std::endl
0115          ;  
0116     return level ; 
0117 }
0118 
0119 inline const char * OPT::DebugLevel_( OptixCompileDebugLevel debugLevel )
0120 {
0121     const char* s = nullptr ; 
0122     switch(debugLevel)
0123     {  
0124 #if OPTIX_VERSION == 70000
0125         case OPTIX_COMPILE_DEBUG_LEVEL_NONE:     s = OPTIX_COMPILE_DEBUG_LEVEL_NONE_     ; break ; 
0126         case OPTIX_COMPILE_DEBUG_LEVEL_LINEINFO: s = OPTIX_COMPILE_DEBUG_LEVEL_LINEINFO_ ; break ;
0127         case OPTIX_COMPILE_DEBUG_LEVEL_FULL:     s = OPTIX_COMPILE_DEBUG_LEVEL_FULL_     ; break ;
0128 #elif OPTIX_VERSION >= 70500
0129         case OPTIX_COMPILE_DEBUG_LEVEL_DEFAULT:  s = OPTIX_COMPILE_DEBUG_LEVEL_DEFAULT_  ; break ; 
0130         case OPTIX_COMPILE_DEBUG_LEVEL_NONE:     s = OPTIX_COMPILE_DEBUG_LEVEL_NONE_     ; break ; 
0131         case OPTIX_COMPILE_DEBUG_LEVEL_MINIMAL:  s = OPTIX_COMPILE_DEBUG_LEVEL_MINIMAL_  ; break ;
0132         case OPTIX_COMPILE_DEBUG_LEVEL_MODERATE: s = OPTIX_COMPILE_DEBUG_LEVEL_MODERATE_ ; break ;
0133         case OPTIX_COMPILE_DEBUG_LEVEL_FULL:     s = OPTIX_COMPILE_DEBUG_LEVEL_FULL_     ; break ;
0134 #endif
0135     }
0136 
0137     if( s == nullptr ) std::cerr
0138         << "OPT::DebugLevel_"
0139         << " debugLevel " << debugLevel 
0140         << " IS NOT RECOGNIZED  "
0141         << " OPTIX_VERSION " << OPTIX_VERSION 
0142         << std::endl 
0143         ; 
0144     return s ;    
0145 }
0146 
0147 inline OptixCompileOptimizationLevel OPT::OptimizationLevel(const char* option) // static 
0148 {
0149     OptixCompileOptimizationLevel level = OPTIX_COMPILE_OPTIMIZATION_DEFAULT ; 
0150     if(      strcmp(option, "LEVEL_0") == 0 )  level = OPTIX_COMPILE_OPTIMIZATION_LEVEL_0  ; 
0151     else if( strcmp(option, "LEVEL_1") == 0 )  level = OPTIX_COMPILE_OPTIMIZATION_LEVEL_1  ; 
0152     else if( strcmp(option, "LEVEL_2") == 0 )  level = OPTIX_COMPILE_OPTIMIZATION_LEVEL_2  ; 
0153     else if( strcmp(option, "LEVEL_3") == 0 )  level = OPTIX_COMPILE_OPTIMIZATION_LEVEL_3  ; 
0154     else if( strcmp(option, "DEFAULT") == 0 )  level = OPTIX_COMPILE_OPTIMIZATION_DEFAULT  ; 
0155     else 
0156     {
0157         std::cerr 
0158             << "OPT::OptimizationLevel "
0159             << " option " << option 
0160             << " IS NOT RECOGNIZED  "
0161             << " level " << level 
0162             << " OPTIX_VERSION " << OPTIX_VERSION 
0163             << std::endl 
0164             ; 
0165         assert(0) ; 
0166     }
0167  
0168     if(VERBOSE) std::cout 
0169         << "OPT::OptimizationLevel " 
0170         << " option " << option 
0171         << " level " << level 
0172         << std::endl 
0173         ;  
0174     return level ; 
0175 }
0176 
0177 inline const char* OPT::OptimizationLevel_( OptixCompileOptimizationLevel optLevel )
0178 {
0179     const char* s = nullptr ; 
0180     switch(optLevel)
0181     {
0182         case OPTIX_COMPILE_OPTIMIZATION_LEVEL_0: s = OPTIX_COMPILE_OPTIMIZATION_LEVEL_0_ ; break ; 
0183         case OPTIX_COMPILE_OPTIMIZATION_LEVEL_1: s = OPTIX_COMPILE_OPTIMIZATION_LEVEL_1_ ; break ; 
0184         case OPTIX_COMPILE_OPTIMIZATION_LEVEL_2: s = OPTIX_COMPILE_OPTIMIZATION_LEVEL_2_ ; break ; 
0185         case OPTIX_COMPILE_OPTIMIZATION_LEVEL_3: s = OPTIX_COMPILE_OPTIMIZATION_LEVEL_3_ ; break ; 
0186         case OPTIX_COMPILE_OPTIMIZATION_DEFAULT: s = OPTIX_COMPILE_OPTIMIZATION_DEFAULT_ ; break ; 
0187         default:                                                                         ; break ; 
0188     }
0189 
0190     if( s == nullptr ) 
0191     {
0192         std::cerr
0193             << "OPT::OptimizationLevel_"
0194             << " optLevel " << optLevel 
0195             << " IS NOT RECOGNIZED  "
0196             << " OPTIX_VERSION " << OPTIX_VERSION 
0197             << std::endl 
0198             ; 
0199         assert(0) ; 
0200     }
0201     return s ; 
0202 } 
0203 
0204 inline OptixExceptionFlags OPT::ExceptionFlags_(const char* opt)
0205 {
0206     OptixExceptionFlags flag = OPTIX_EXCEPTION_FLAG_NONE ; 
0207     if(      strcmp(opt, "NONE") == 0 )          flag = OPTIX_EXCEPTION_FLAG_NONE ;  
0208     else if( strcmp(opt, "STACK_OVERFLOW") == 0) flag = OPTIX_EXCEPTION_FLAG_STACK_OVERFLOW ; 
0209     else if( strcmp(opt, "TRACE_DEPTH") == 0)    flag = OPTIX_EXCEPTION_FLAG_TRACE_DEPTH  ; 
0210     else if( strcmp(opt, "USER") == 0)           flag = OPTIX_EXCEPTION_FLAG_USER  ; 
0211 #if OPTIX_VERSION <= 70700
0212     else if( strcmp(opt, "DEBUG") == 0)          flag = OPTIX_EXCEPTION_FLAG_DEBUG  ; 
0213 #endif
0214     else 
0215     {
0216         std::cerr 
0217             << "OPT::ExceptionFlags_"
0218             << " opt " << opt
0219             << " IS NOT RECOGNIZED  "
0220             << " flag " << flag
0221             << " OPTIX_VERSION " << OPTIX_VERSION 
0222             << std::endl 
0223             ; 
0224         assert(0) ; 
0225     }
0226     return flag ; 
0227 }
0228 
0229 inline const char* OPT::ExceptionFlags__(OptixExceptionFlags excFlag)
0230 {
0231     const char* s = nullptr ; 
0232     switch(excFlag)
0233     {
0234         case OPTIX_EXCEPTION_FLAG_NONE:           s = OPTIX_EXCEPTION_FLAG_NONE_            ; break ; 
0235         case OPTIX_EXCEPTION_FLAG_STACK_OVERFLOW: s = OPTIX_EXCEPTION_FLAG_STACK_OVERFLOW_  ; break ;
0236         case OPTIX_EXCEPTION_FLAG_TRACE_DEPTH:    s = OPTIX_EXCEPTION_FLAG_TRACE_DEPTH_     ; break ; 
0237         case OPTIX_EXCEPTION_FLAG_USER:           s = OPTIX_EXCEPTION_FLAG_USER_            ; break ; 
0238 #if OPTIX_VERSION <= 70700
0239         case OPTIX_EXCEPTION_FLAG_DEBUG:          s = OPTIX_EXCEPTION_FLAG_DEBUG_           ; break ;      
0240 #endif
0241     }
0242     return s ; 
0243 }
0244 
0245 inline unsigned OPT::ExceptionFlags(const char* options)
0246 {
0247     std::vector<std::string> opts ; 
0248     sstr::Split( options, '|', opts );  
0249 
0250     unsigned exceptionFlags = OPTIX_EXCEPTION_FLAG_NONE ; 
0251     for(unsigned i=0 ; i < opts.size() ; i++)
0252     {
0253         const std::string& opt = opts[i] ; 
0254         exceptionFlags |= ExceptionFlags_(opt.c_str()); 
0255     }
0256     if(VERBOSE) std::cerr 
0257         << "OPT::ExceptionFlags"  
0258         << " options " << options 
0259         << " exceptionFlags " << exceptionFlags 
0260         << std::endl 
0261         ; 
0262     return exceptionFlags ;  
0263 }
0264 
0265 inline std::string OPT::Desc_ExceptionFlags( unsigned flags )
0266 {
0267     std::stringstream ss ; 
0268     if( flags & OPTIX_EXCEPTION_FLAG_NONE )           ss << OPTIX_EXCEPTION_FLAG_NONE_ << " " ; 
0269     if( flags & OPTIX_EXCEPTION_FLAG_STACK_OVERFLOW ) ss << OPTIX_EXCEPTION_FLAG_STACK_OVERFLOW_ << " " ; 
0270     if( flags & OPTIX_EXCEPTION_FLAG_TRACE_DEPTH )    ss << OPTIX_EXCEPTION_FLAG_TRACE_DEPTH_ << " " ; 
0271     if( flags & OPTIX_EXCEPTION_FLAG_USER )           ss << OPTIX_EXCEPTION_FLAG_USER_ << " " ; 
0272 #if OPTIX_VERSION <= 70700
0273     if( flags & OPTIX_EXCEPTION_FLAG_DEBUG )          ss << OPTIX_EXCEPTION_FLAG_DEBUG_ << " " ; 
0274 #endif
0275     std::string str = ss.str() ; 
0276     return str ; 
0277 }
0278 
0279
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.3.7 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!