Revert "Cycles: Change OpenCL split kernel to use single program by default"
[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 "bvh/bvh_params.h"
22
23 #include "util/util_logging.h"
24 #include "util/util_string.h"
25
26 CCL_NAMESPACE_BEGIN
27
28 DebugFlags::CPU::CPU()
29   : avx2(true),
30     avx(true),
31     sse41(true),
32     sse3(true),
33     sse2(true),
34     bvh_layout(BVH_LAYOUT_DEFAULT),
35     split_kernel(false)
36 {
37         reset();
38 }
39
40 void DebugFlags::CPU::reset()
41 {
42 #define STRINGIFY(x) #x
43 #define CHECK_CPU_FLAGS(flag, env) \
44         do { \
45                 flag = (getenv(env) == NULL); \
46                 if(!flag) { \
47                         VLOG(1) << "Disabling " << STRINGIFY(flag) << " instruction set."; \
48                 } \
49         } while(0)
50
51         CHECK_CPU_FLAGS(avx2, "CYCLES_CPU_NO_AVX2");
52         CHECK_CPU_FLAGS(avx, "CYCLES_CPU_NO_AVX");
53         CHECK_CPU_FLAGS(sse41, "CYCLES_CPU_NO_SSE41");
54         CHECK_CPU_FLAGS(sse3, "CYCLES_CPU_NO_SSE3");
55         CHECK_CPU_FLAGS(sse2, "CYCLES_CPU_NO_SSE2");
56
57 #undef STRINGIFY
58 #undef CHECK_CPU_FLAGS
59
60         if(getenv("CYCLES_BVH2") != NULL) {
61                 bvh_layout = BVH_LAYOUT_BVH2;
62         }
63         else if(getenv("CYCLES_BVH4") != NULL) {
64                 bvh_layout = BVH_LAYOUT_BVH4;
65         }
66         else if(getenv("CYCLES_BVH8") != NULL) {
67                 bvh_layout = BVH_LAYOUT_BVH8;
68         }
69         else {
70                 bvh_layout = BVH_LAYOUT_DEFAULT;
71         }
72
73         split_kernel = false;
74 }
75
76 DebugFlags::CUDA::CUDA()
77   : adaptive_compile(false),
78     split_kernel(false)
79 {
80         reset();
81 }
82
83 void DebugFlags::CUDA::reset()
84 {
85         if(getenv("CYCLES_CUDA_ADAPTIVE_COMPILE") != NULL)
86                 adaptive_compile = true;
87
88         split_kernel = false;
89 }
90
91 DebugFlags::OpenCL::OpenCL()
92   : device_type(DebugFlags::OpenCL::DEVICE_ALL),
93     kernel_type(DebugFlags::OpenCL::KERNEL_DEFAULT),
94     debug(false),
95     single_program(false)
96 {
97         reset();
98 }
99
100 void DebugFlags::OpenCL::reset()
101 {
102         /* Initialize device type from environment variables. */
103         device_type = DebugFlags::OpenCL::DEVICE_ALL;
104         char *device = getenv("CYCLES_OPENCL_TEST");
105         if(device) {
106                 if(strcmp(device, "NONE") == 0) {
107                         device_type = DebugFlags::OpenCL::DEVICE_NONE;
108                 }
109                 else if(strcmp(device, "ALL") == 0) {
110                         device_type = DebugFlags::OpenCL::DEVICE_ALL;
111                 }
112                 else if(strcmp(device, "DEFAULT") == 0) {
113                         device_type = DebugFlags::OpenCL::DEVICE_DEFAULT;
114                 }
115                 else if(strcmp(device, "CPU") == 0) {
116                         device_type = DebugFlags::OpenCL::DEVICE_CPU;
117                 }
118                 else if(strcmp(device, "GPU") == 0) {
119                         device_type = DebugFlags::OpenCL::DEVICE_GPU;
120                 }
121                 else if(strcmp(device, "ACCELERATOR") == 0) {
122                         device_type = DebugFlags::OpenCL::DEVICE_ACCELERATOR;
123                 }
124         }
125         /* Initialize kernel type from environment variables. */
126         kernel_type = DebugFlags::OpenCL::KERNEL_DEFAULT;
127         if(getenv("CYCLES_OPENCL_MEGA_KERNEL_TEST") != NULL) {
128                 kernel_type = DebugFlags::OpenCL::KERNEL_MEGA;
129         }
130         else if(getenv("CYCLES_OPENCL_SPLIT_KERNEL_TEST") != NULL) {
131                 kernel_type = DebugFlags::OpenCL::KERNEL_SPLIT;
132         }
133         /* Initialize other flags from environment variables. */
134         debug = (getenv("CYCLES_OPENCL_DEBUG") != NULL);
135         single_program = (getenv("CYCLES_OPENCL_SINGLE_PROGRAM") != NULL);
136 }
137
138 DebugFlags::DebugFlags()
139 : viewport_static_bvh(false)
140 {
141         /* Nothing for now. */
142 }
143
144 void DebugFlags::reset()
145 {
146         viewport_static_bvh = false;
147         cpu.reset();
148         cuda.reset();
149         opencl.reset();
150 }
151
152 std::ostream& operator <<(std::ostream &os,
153                           DebugFlagsConstRef debug_flags)
154 {
155         os << "CPU flags:\n"
156            << "  AVX2       : " << string_from_bool(debug_flags.cpu.avx2) << "\n"
157            << "  AVX        : " << string_from_bool(debug_flags.cpu.avx) << "\n"
158            << "  SSE4.1     : " << string_from_bool(debug_flags.cpu.sse41) << "\n"
159            << "  SSE3       : " << string_from_bool(debug_flags.cpu.sse3) << "\n"
160            << "  SSE2       : " << string_from_bool(debug_flags.cpu.sse2) << "\n"
161            << "  BVH layout : " << bvh_layout_name(debug_flags.cpu.bvh_layout) << "\n"
162            << "  Split      : " << string_from_bool(debug_flags.cpu.split_kernel) << "\n";
163
164         os << "CUDA flags:\n"
165            << " Adaptive Compile: " << string_from_bool(debug_flags.cuda.adaptive_compile) << "\n";
166
167         const char *opencl_device_type,
168                    *opencl_kernel_type;
169         switch(debug_flags.opencl.device_type) {
170                 case DebugFlags::OpenCL::DEVICE_NONE:
171                         opencl_device_type = "NONE";
172                         break;
173                 case DebugFlags::OpenCL::DEVICE_ALL:
174                         opencl_device_type = "ALL";
175                         break;
176                 case DebugFlags::OpenCL::DEVICE_DEFAULT:
177                         opencl_device_type = "DEFAULT";
178                         break;
179                 case DebugFlags::OpenCL::DEVICE_CPU:
180                         opencl_device_type = "CPU";
181                         break;
182                 case DebugFlags::OpenCL::DEVICE_GPU:
183                         opencl_device_type = "GPU";
184                         break;
185                 case DebugFlags::OpenCL::DEVICE_ACCELERATOR:
186                         opencl_device_type = "ACCELERATOR";
187                         break;
188         }
189         switch(debug_flags.opencl.kernel_type) {
190                 case DebugFlags::OpenCL::KERNEL_DEFAULT:
191                         opencl_kernel_type = "DEFAULT";
192                         break;
193                 case DebugFlags::OpenCL::KERNEL_MEGA:
194                         opencl_kernel_type = "MEGA";
195                         break;
196                 case DebugFlags::OpenCL::KERNEL_SPLIT:
197                         opencl_kernel_type = "SPLIT";
198                         break;
199         }
200         os << "OpenCL flags:\n"
201            << "  Device type    : " << opencl_device_type << "\n"
202            << "  Kernel type    : " << opencl_kernel_type << "\n"
203            << "  Debug          : " << string_from_bool(debug_flags.opencl.debug) << "\n"
204            << "  Single program : " << string_from_bool(debug_flags.opencl.single_program) << "\n"
205            << "  Memory limit   : " << string_human_readable_size(debug_flags.opencl.mem_limit) << "\n";
206         return os;
207 }
208
209 CCL_NAMESPACE_END