Merge remote-tracking branch 'origin/master' into blender2.8
[blender.git] / intern / cycles / util / util_debug.h
1 /*
2  * Copyright 2011-2013 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 #ifndef __UTIL_DEBUG_H__
18 #define __UTIL_DEBUG_H__
19
20 #include <cassert>
21 #include <iostream>
22
23 CCL_NAMESPACE_BEGIN
24
25 /* Global storage for all sort of flags used to fine-tune behavior of particular
26  * areas for the development purposes, without officially exposing settings to
27  * the interface.
28  */
29 class DebugFlags {
30 public:
31         /* Use static BVH in viewport, to match final render exactly. */
32         bool viewport_static_bvh;
33
34         /* Descriptor of CPU feature-set to be used. */
35         struct CPU {
36                 CPU();
37
38                 /* Reset flags to their defaults. */
39                 void reset();
40
41                 /* Flags describing which instructions sets are allowed for use. */
42                 bool avx2;
43                 bool avx;
44                 bool sse41;
45                 bool sse3;
46                 bool sse2;
47
48                 /* Check functions to see whether instructions up to the given one
49                  * are allowed for use.
50                  */
51                 bool has_avx2()  { return has_avx()   && avx2; }
52                 bool has_avx()   { return has_sse41() && avx; }
53                 bool has_sse41() { return has_sse3()  && sse41; }
54                 bool has_sse3()  { return has_sse2()  && sse3; }
55                 bool has_sse2()  { return sse2; }
56
57                 /* Whether QBVH usage is allowed or not. */
58                 bool qbvh;
59
60                 /* Whether split kernel is used */
61                 bool split_kernel;
62         };
63
64         /* Descriptor of CUDA feature-set to be used. */
65         struct CUDA {
66                 CUDA();
67
68                 /* Reset flags to their defaults. */
69                 void reset();
70
71                 /* Whether adaptive feature based runtime compile is enabled or not.
72                  * Requires the CUDA Toolkit and only works on Linux atm. */
73                 bool adaptive_compile;
74
75                 /* Whether split kernel is used */
76                 bool split_kernel;
77         };
78
79         /* Descriptor of OpenCL feature-set to be used. */
80         struct OpenCL {
81                 OpenCL();
82
83                 /* Reset flags to their defaults. */
84                 void reset();
85
86                 /* Available device types.
87                  * Only gives a hint which devices to let user to choose from, does not
88                  * try to use any sort of optimal device or so.
89                  */
90                 enum DeviceType {
91                         /* None of OpenCL devices will be used. */
92                         DEVICE_NONE,
93                         /* All OpenCL devices will be used. */
94                         DEVICE_ALL,
95                         /* Default system OpenCL device will be used.  */
96                         DEVICE_DEFAULT,
97                         /* Host processor will be used. */
98                         DEVICE_CPU,
99                         /* GPU devices will be used. */
100                         DEVICE_GPU,
101                         /* Dedicated OpenCL accelerator device will be used. */
102                         DEVICE_ACCELERATOR,
103                 };
104
105                 /* Available kernel types. */
106                 enum KernelType {
107                         /* Do automated guess which kernel to use, based on the officially
108                          * supported GPUs and such.
109                          */
110                         KERNEL_DEFAULT,
111                         /* Force mega kernel to be used. */
112                         KERNEL_MEGA,
113                         /* Force split kernel to be used. */
114                         KERNEL_SPLIT,
115                 };
116
117                 /* Requested device type. */
118                 DeviceType device_type;
119
120                 /* Requested kernel type. */
121                 KernelType kernel_type;
122
123                 /* Use debug version of the kernel. */
124                 bool debug;
125
126                 /* Use single program */
127                 bool single_program;
128
129                 /* TODO(mai): Currently this is only for OpenCL, but we should have it implemented for all devices. */
130                 /* Artificial memory limit in bytes (0 if disabled). */
131                 size_t mem_limit;
132         };
133
134         /* Get instance of debug flags registry. */
135         static DebugFlags& get()
136         {
137                 static DebugFlags instance;
138                 return instance;
139         }
140
141         /* Reset flags to their defaults. */
142         void reset();
143
144         /* Requested CPU flags. */
145         CPU cpu;
146
147         /* Requested CUDA flags. */
148         CUDA cuda;
149
150         /* Requested OpenCL flags. */
151         OpenCL opencl;
152
153 private:
154         DebugFlags();
155
156 #if (__cplusplus > 199711L)
157 public:
158         explicit DebugFlags(DebugFlags const& /*other*/)     = delete;
159         void operator=(DebugFlags const& /*other*/) = delete;
160 #else
161 private:
162         explicit DebugFlags(DebugFlags const& /*other*/);
163         void operator=(DebugFlags const& /*other*/);
164 #endif
165 };
166
167 typedef DebugFlags& DebugFlagsRef;
168 typedef const DebugFlags& DebugFlagsConstRef;
169
170 inline DebugFlags& DebugFlags() {
171   return DebugFlags::get();
172 }
173
174 std::ostream& operator <<(std::ostream &os,
175                           DebugFlagsConstRef debug_flags);
176
177 CCL_NAMESPACE_END
178
179 #endif /* __UTIL_DEBUG_H__ */