Back to home page

EIC code displayed by LXR
 
 

    

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

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