intern/cycles/util/util_debug.cpp

   1 /*
   2  * Copyright 2011-2016 Blender Foundation
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "util/util_debug.h"
  18
  19 #include <stdlib.h>
  20
  21 #include "util/util_logging.h"
  22 #include "util/util_string.h"
  23
  24 CCL_NAMESPACE_BEGIN
  25
  26 DebugFlags::CPU::CPU()
  27   : avx2(true),
  28     avx(true),
  29     sse41(true),
  30     sse3(true),
  31     sse2(true),
  32     qbvh(true),
  33     split_kernel(false)
  34 {
  35         reset();
  36 }
  37
  38 void DebugFlags::CPU::reset()
  39 {
  40 #define STRINGIFY(x) #x
  41 #define CHECK_CPU_FLAGS(flag, env) \
  42         do { \
  43                 flag = (getenv(env) == NULL); \
  44                 if(!flag) { \
  45                         VLOG(1) << "Disabling " << STRINGIFY(flag) << " instruction set."; \
  46                 } \
  47         } while(0)
  48
  49         CHECK_CPU_FLAGS(avx2, "CYCLES_CPU_NO_AVX2");
  50         CHECK_CPU_FLAGS(avx, "CYCLES_CPU_NO_AVX");
  51         CHECK_CPU_FLAGS(sse41, "CYCLES_CPU_NO_SSE41");
  52         CHECK_CPU_FLAGS(sse3, "CYCLES_CPU_NO_SSE3");
  53         CHECK_CPU_FLAGS(sse2, "CYCLES_CPU_NO_SSE2");
  54
  55 #undef STRINGIFY
  56 #undef CHECK_CPU_FLAGS
  57
  58         qbvh = true;
  59         split_kernel = false;
  60 }
  61
  62 DebugFlags::CUDA::CUDA()
  63   : adaptive_compile(false),
  64     split_kernel(false)
  65 {
  66         reset();
  67 }
  68
  69 void DebugFlags::CUDA::reset()
  70 {
  71         if(getenv("CYCLES_CUDA_ADAPTIVE_COMPILE") != NULL)
  72                 adaptive_compile = true;
  73
  74         split_kernel = false;
  75 }
  76
  77 DebugFlags::OpenCL::OpenCL()
  78   : device_type(DebugFlags::OpenCL::DEVICE_ALL),
  79     kernel_type(DebugFlags::OpenCL::KERNEL_DEFAULT),
  80     debug(false),
  81     single_program(false)
  82 {
  83         reset();
  84 }
  85
  86 void DebugFlags::OpenCL::reset()
  87 {
  88         /* Initialize device type from environment variables. */
  89         device_type = DebugFlags::OpenCL::DEVICE_ALL;
  90         char *device = getenv("CYCLES_OPENCL_TEST");
  91         if(device) {
  92                 if(strcmp(device, "NONE") == 0) {
  93                         device_type = DebugFlags::OpenCL::DEVICE_NONE;
  94                 }
  95                 else if(strcmp(device, "ALL") == 0) {
  96                         device_type = DebugFlags::OpenCL::DEVICE_ALL;
  97                 }
  98                 else if(strcmp(device, "DEFAULT") == 0) {
  99                         device_type = DebugFlags::OpenCL::DEVICE_DEFAULT;
 100                 }
 101                 else if(strcmp(device, "CPU") == 0) {
 102                         device_type = DebugFlags::OpenCL::DEVICE_CPU;
 103                 }
 104                 else if(strcmp(device, "GPU") == 0) {
 105                         device_type = DebugFlags::OpenCL::DEVICE_GPU;
 106                 }
 107                 else if(strcmp(device, "ACCELERATOR") == 0) {
 108                         device_type = DebugFlags::OpenCL::DEVICE_ACCELERATOR;
 109                 }
 110         }
 111         /* Initialize kernel type from environment variables. */
 112         kernel_type = DebugFlags::OpenCL::KERNEL_DEFAULT;
 113         if(getenv("CYCLES_OPENCL_MEGA_KERNEL_TEST") != NULL) {
 114                 kernel_type = DebugFlags::OpenCL::KERNEL_MEGA;
 115         }
 116         else if(getenv("CYCLES_OPENCL_SPLIT_KERNEL_TEST") != NULL) {
 117                 kernel_type = DebugFlags::OpenCL::KERNEL_SPLIT;
 118         }
 119         /* Initialize other flags from environment variables. */
 120         debug = (getenv("CYCLES_OPENCL_DEBUG") != NULL);
 121         single_program = (getenv("CYCLES_OPENCL_MULTI_PROGRAM") == NULL);
 122 }
 123
 124 DebugFlags::DebugFlags()
 125 {
 126         /* Nothing for now. */
 127 }
 128
 129 void DebugFlags::reset()
 130 {
 131         cpu.reset();
 132         opencl.reset();
 133 }
 134
 135 std::ostream& operator <<(std::ostream &os,
 136                           DebugFlagsConstRef debug_flags)
 137 {
 138         os << "CPU flags:\n"
 139            << "  AVX2   : " << string_from_bool(debug_flags.cpu.avx2)  << "\n"
 140            << "  AVX    : " << string_from_bool(debug_flags.cpu.avx)   << "\n"
 141            << "  SSE4.1 : " << string_from_bool(debug_flags.cpu.sse41) << "\n"
 142            << "  SSE3   : " << string_from_bool(debug_flags.cpu.sse3)  << "\n"
 143            << "  SSE2   : " << string_from_bool(debug_flags.cpu.sse2)  << "\n"
 144            << "  QBVH   : " << string_from_bool(debug_flags.cpu.qbvh)  << "\n"
 145            << "  Split  : " << string_from_bool(debug_flags.cpu.split_kernel) << "\n";
 146
 147         os << "CUDA flags:\n"
 148            << " Adaptive Compile: " << string_from_bool(debug_flags.cuda.adaptive_compile) << "\n";
 149
 150         const char *opencl_device_type,
 151                    *opencl_kernel_type;
 152         switch(debug_flags.opencl.device_type) {
 153                 case DebugFlags::OpenCL::DEVICE_NONE:
 154                         opencl_device_type = "NONE";
 155                         break;
 156                 case DebugFlags::OpenCL::DEVICE_ALL:
 157                         opencl_device_type = "ALL";
 158                         break;
 159                 case DebugFlags::OpenCL::DEVICE_DEFAULT:
 160                         opencl_device_type = "DEFAULT";
 161                         break;
 162                 case DebugFlags::OpenCL::DEVICE_CPU:
 163                         opencl_device_type = "CPU";
 164                         break;
 165                 case DebugFlags::OpenCL::DEVICE_GPU:
 166                         opencl_device_type = "GPU";
 167                         break;
 168                 case DebugFlags::OpenCL::DEVICE_ACCELERATOR:
 169                         opencl_device_type = "ACCELERATOR";
 170                         break;
 171         }
 172         switch(debug_flags.opencl.kernel_type) {
 173                 case DebugFlags::OpenCL::KERNEL_DEFAULT:
 174                         opencl_kernel_type = "DEFAULT";
 175                         break;
 176                 case DebugFlags::OpenCL::KERNEL_MEGA:
 177                         opencl_kernel_type = "MEGA";
 178                         break;
 179                 case DebugFlags::OpenCL::KERNEL_SPLIT:
 180                         opencl_kernel_type = "SPLIT";
 181                         break;
 182         }
 183         os << "OpenCL flags:\n"
 184            << "  Device type    : " << opencl_device_type << "\n"
 185            << "  Kernel type    : " << opencl_kernel_type << "\n"
 186            << "  Debug          : " << string_from_bool(debug_flags.opencl.debug) << "\n"
 187            << "  Signle program : " << string_from_bool(debug_flags.opencl.single_program)
 188            << "\n";
 189         return os;
 190 }
 191
 192 CCL_NAMESPACE_END