Cycles: Make all #include statements relative to cycles source directory
[blender.git] / 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_SINGLE_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