sandey/blender
1
0
Fork 0
forked from bartvdbraak/blender
Code Pull Requests Activity
8bf9bf37ec
blender/intern/cycles/util/util_system.cpp

233 lines
4.6 KiB
C++
Raw Normal View History

Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
/*
Cycles: relicense GNU GPL source code to Apache version 2.0. More information in this post: http://code.blender.org/ Thanks to all contributes for giving their permission!
2013-08-18 14:16:15 +00:00
* Copyright 2011-2013 Blender Foundation
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
*
Cycles: relicense GNU GPL source code to Apache version 2.0. More information in this post: http://code.blender.org/ Thanks to all contributes for giving their permission!
2013-08-18 14:16:15 +00:00
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
*
Cycles: relicense GNU GPL source code to Apache version 2.0. More information in this post: http://code.blender.org/ Thanks to all contributes for giving their permission!
2013-08-18 14:16:15 +00:00
* http://www.apache.org/licenses/LICENSE-2.0
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
*
Cycles: relicense GNU GPL source code to Apache version 2.0. More information in this post: http://code.blender.org/ Thanks to all contributes for giving their permission!
2013-08-18 14:16:15 +00:00
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
*/
#include "util_system.h"
#include "util_types.h"
#ifdef _WIN32
Compile fixes for MinGW, checked with basic initial setup, no CUDA, gcc 4.5.2. OpenImageIO still gives link-time errors, will try to make a lib for MinGW, see if it is fixed.
2011-09-04 15:39:09 +00:00
#if(!defined(FREE_WINDOWS))
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
#include <intrin.h>
Compile fixes for MinGW, checked with basic initial setup, no CUDA, gcc 4.5.2. OpenImageIO still gives link-time errors, will try to make a lib for MinGW, see if it is fixed.
2011-09-04 15:39:09 +00:00
#endif
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
#include <windows.h>
#elif defined(__APPLE__)
#include <sys/sysctl.h>
#include <sys/types.h>
#else
#include <unistd.h>
#endif
CCL_NAMESPACE_BEGIN
int system_cpu_thread_count()
{
static uint count = 0;
if(count > 0)
return count;
#ifdef _WIN32
SYSTEM_INFO info;
GetSystemInfo(&info);
count = (uint)info.dwNumberOfProcessors;
#elif defined(__APPLE__)
size_t len = sizeof(count);
int mib[2] = { CTL_HW, HW_NCPU };
sysctl(mib, 2, &count, &len, NULL, 0);
#else
count = (uint)sysconf(_SC_NPROCESSORS_ONLN);
#endif
if(count < 1)
count = 1;
return count;
}
Compile fixes for MinGW, checked with basic initial setup, no CUDA, gcc 4.5.2. OpenImageIO still gives link-time errors, will try to make a lib for MinGW, see if it is fixed.
2011-09-04 15:39:09 +00:00
#if !defined(_WIN32) || defined(FREE_WINDOWS)
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
static void __cpuid(int data[4], int selector)
{
Cycles: two 32 bit fixes with help from IRC user Agiofws.
2011-05-05 13:51:33 +00:00
#ifdef __x86_64__
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
asm("cpuid" : "=a" (data[0]), "=b" (data[1]), "=c" (data[2]), "=d" (data[3]) : "a"(selector));
Cycles: two 32 bit fixes with help from IRC user Agiofws.
2011-05-05 13:51:33 +00:00
#else
#ifdef __i386__
asm("pushl %%ebx \n\t"
"cpuid \n\t"
"movl %%ebx, %1 \n\t"
"popl %%ebx \n\t" : "=a" (data[0]), "=r" (data[1]), "=c" (data[2]), "=d" (data[3]) : "a"(selector));
#else
data[0] = data[1] = data[2] = data[3] = 0;
#endif
#endif
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
}
#endif
static void replace_string(string& haystack, const string& needle, const string& other)
{
size_t i;
while((i = haystack.find(needle)) != string::npos)
haystack.replace(i, needle.length(), other);
}
string system_cpu_brand_string()
{
char buf[48];
int result[4];
__cpuid(result, 0x80000000);
if(result[0] >= (int)0x80000004) {
__cpuid((int*)(buf+0), 0x80000002);
__cpuid((int*)(buf+16), 0x80000003);
__cpuid((int*)(buf+32), 0x80000004);
string brand = buf;
/* make it a bit more presentable */
replace_string(brand, "(TM)", "");
replace_string(brand, "(R)", "");
Cycles: network render code updated for latest changes and improved This actually works somewhat now, although viewport rendering is broken and any kind of network error or connection failure will kill Blender. * Experimental WITH_CYCLES_NETWORK cmake option * Networked Device is shown as an option next to CPU and GPU Compute * Various updates to work with the latest Cycles code * Locks and thread safety for RPC calls and tiles * Refactored pointer mapping code * Fix error in CPU brand string retrieval code This includes work by Doug Gale, Martijn Berger and Brecht Van Lommel. Reviewers: brecht Differential Revision: http://developer.blender.org/D36
2013-12-07 01:29:53 +00:00
brand = string_strip(brand);
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
return brand;
}
return "Unknown CPU";
}
Cycles: some warning fixes, cpu device task tweaks, avoid unnecessary tonemap in non-viewport render, and some utility functions.
2011-09-08 18:58:07 +00:00
int system_cpu_bits()
{
return (sizeof(void*)*8);
}
Better fix for #36935 and 36316: * 32 bit GCC builds now have the SSE BVH optimizations turned off, but still compile with SSE flags for better performance. * White color when rendering on Windows seems to have been unrelated to SSE, rather it was a graphics driver not supporting half float textures, added a check for that now.
2013-10-05 19:56:34 +00:00
#if defined(__x86_64__) || defined(_M_X64) || defined(i386) || defined(_M_IX86)
Fix #29259: cycles issues on certain processors. Now two versions of the kernel are compiled, one SSE optimized and the other not, and it will choose between them at runtime.
2011-11-15 15:13:38 +00:00
struct CPUCapabilities {
bool x64;
bool mmx;
bool sse;
bool sse2;
bool sse3;
bool ssse3;
bool sse41;
bool sse42;
bool sse4a;
bool avx;
bool xop;
bool fma3;
bool fma4;
};
Fix cycles intersection issue with overlapping faces on windows 32 bit and CPU without SSE3 support, due to 80 bit precision float register being used for one bounding box but not the one next to it.
2013-02-04 16:12:37 +00:00
static CPUCapabilities& system_cpu_capabilities()
Fix #29259: cycles issues on certain processors. Now two versions of the kernel are compiled, one SSE optimized and the other not, and it will choose between them at runtime.
2011-11-15 15:13:38 +00:00
{
static CPUCapabilities caps;
static bool caps_init = false;
if(!caps_init) {
Cycles: * Fix broken compile of test app. * Fix some warnings compiling with gcc for 32 bit. * More tweaks to avoid extended precision issue from #29301.
2011-12-02 14:26:28 +00:00
int result[4], num; //, num_ex;
Fix #29259: cycles issues on certain processors. Now two versions of the kernel are compiled, one SSE optimized and the other not, and it will choose between them at runtime.
2011-11-15 15:13:38 +00:00
memset(&caps, 0, sizeof(caps));
__cpuid(result, 0);
num = result[0];
style cleanup: block comments
2012-06-09 17:22:52 +00:00
#if 0
__cpuid(result, 0x80000000);
num_ex = result[0];
#endif
Fix #29259: cycles issues on certain processors. Now two versions of the kernel are compiled, one SSE optimized and the other not, and it will choose between them at runtime.
2011-11-15 15:13:38 +00:00
style cleanup
2012-06-06 22:38:39 +00:00
if(num >= 1) {
Fix #29259: cycles issues on certain processors. Now two versions of the kernel are compiled, one SSE optimized and the other not, and it will choose between them at runtime.
2011-11-15 15:13:38 +00:00
__cpuid(result, 0x00000001);
caps.mmx = (result[3] & ((int)1 << 23)) != 0;
caps.sse = (result[3] & ((int)1 << 25)) != 0;
caps.sse2 = (result[3] & ((int)1 << 26)) != 0;
caps.sse3 = (result[2] & ((int)1 << 0)) != 0;
caps.ssse3 = (result[2] & ((int)1 << 9)) != 0;
caps.sse41 = (result[2] & ((int)1 << 19)) != 0;
caps.sse42 = (result[2] & ((int)1 << 20)) != 0;
caps.avx = (result[2] & ((int)1 << 28)) != 0;
caps.fma3 = (result[2] & ((int)1 << 12)) != 0;
}
style cleanup: block comments
2012-06-09 17:22:52 +00:00
#if 0
if(num_ex >= 0x80000001) {
Fix #29259: cycles issues on certain processors. Now two versions of the kernel are compiled, one SSE optimized and the other not, and it will choose between them at runtime.
2011-11-15 15:13:38 +00:00
__cpuid(result, 0x80000001);
caps.x64 = (result[3] & ((int)1 << 29)) != 0;
caps.sse4a = (result[2] & ((int)1 << 6)) != 0;
caps.fma4 = (result[2] & ((int)1 << 16)) != 0;
caps.xop = (result[2] & ((int)1 << 11)) != 0;
style cleanup: block comments
2012-06-09 17:22:52 +00:00
}
#endif
Fix #29259: cycles issues on certain processors. Now two versions of the kernel are compiled, one SSE optimized and the other not, and it will choose between them at runtime.
2011-11-15 15:13:38 +00:00
caps_init = true;
}
Fix cycles intersection issue with overlapping faces on windows 32 bit and CPU without SSE3 support, due to 80 bit precision float register being used for one bounding box but not the one next to it.
2013-02-04 16:12:37 +00:00
return caps;
}
bool system_cpu_support_sse2()
{
CPUCapabilities& caps = system_cpu_capabilities();
return caps.sse && caps.sse2;
}
bool system_cpu_support_sse3()
{
CPUCapabilities& caps = system_cpu_capabilities();
Fix cycles crash on some processors. We actually need S-SSE3 support for this new BVH traversal code, not just SSE3.
2013-06-18 16:52:02 +00:00
return caps.sse && caps.sse2 && caps.sse3 && caps.ssse3;
Fix #29259: cycles issues on certain processors. Now two versions of the kernel are compiled, one SSE optimized and the other not, and it will choose between them at runtime.
2011-11-15 15:13:38 +00:00
}
Cycles: test code for sse 4.1 kernel and alignment for some vector types. This is mostly work towards enabling the __KERNEL_SSE__ option to start using SIMD operations for vector math operations. This 4.1 kernel performes about 8% faster with that option but overall is still slower than without the option. WITH_CYCLES_OPTIMIZED_KERNEL_SSE41 is the cmake flag for testing this kernel. Alignment of int3, int4, float3, float4 to 16 bytes seems to give a slight 1-2% speedup on tested systems with the current kernel already, so is enabled now.
2013-11-22 13:16:47 +00:00
bool system_cpu_support_sse41()
{
CPUCapabilities& caps = system_cpu_capabilities();
return caps.sse && caps.sse2 && caps.sse3 && caps.ssse3 && caps.sse41;
}
Cycles: Add an AVX kernel for CPU rendering. * AVX is available on Intel Sandy Bridge and newer and AMD Bulldozer and newer. * We don't use dedicated AVX intrinsics yet, but gcc auto vectorization gives a 3% performance improvement for Caminandes. Tested on an i5-3570, Linux x64. * No change for Windows yet, MSVC 2008 does not support AVX. Reviewed by: brecht Differential Revision: https://developer.blender.org/D216
2014-01-16 16:04:11 +00:00
bool system_cpu_support_avx()
{
CPUCapabilities& caps = system_cpu_capabilities();
return caps.sse && caps.sse2 && caps.sse3 && caps.ssse3 && caps.sse41 && caps.avx;
}
Fix #29259: cycles issues on certain processors. Now two versions of the kernel are compiled, one SSE optimized and the other not, and it will choose between them at runtime.
2011-11-15 15:13:38 +00:00
#else
Fix build error on non-x86 architectures as pointed out by Jochen Schmitt.
2013-06-04 11:21:13 +00:00
bool system_cpu_support_sse2()
{
return false;
}
bool system_cpu_support_sse3()
Fix #29259: cycles issues on certain processors. Now two versions of the kernel are compiled, one SSE optimized and the other not, and it will choose between them at runtime.
2011-11-15 15:13:38 +00:00
{
return false;
}
Cycles: Add an AVX kernel for CPU rendering. * AVX is available on Intel Sandy Bridge and newer and AMD Bulldozer and newer. * We don't use dedicated AVX intrinsics yet, but gcc auto vectorization gives a 3% performance improvement for Caminandes. Tested on an i5-3570, Linux x64. * No change for Windows yet, MSVC 2008 does not support AVX. Reviewed by: brecht Differential Revision: https://developer.blender.org/D216
2014-01-16 16:04:11 +00:00
bool system_cpu_support_sse41()
{
return false;
}
bool system_cpu_support_avx()
{
return false;
}
Fix #29259: cycles issues on certain processors. Now two versions of the kernel are compiled, one SSE optimized and the other not, and it will choose between them at runtime.
2011-11-15 15:13:38 +00:00
#endif
Cycles render engine, initial commit. This is the engine itself, blender modifications and build instructions will follow later. Cycles uses code from some great open source projects, many thanks them: * BVH building and traversal code from NVidia's "Understanding the Efficiency of Ray Traversal on GPUs": http://code.google.com/p/understanding-the-efficiency-of-ray-traversal-on-gpus/ * Open Shading Language for a large part of the shading system: http://code.google.com/p/openshadinglanguage/ * Blender for procedural textures and a few other nodes. * Approximate Catmull Clark subdivision from NVidia Mesh tools: http://code.google.com/p/nvidia-mesh-tools/ * Sobol direction vectors from: http://web.maths.unsw.edu.au/~fkuo/sobol/ * Film response functions from: http://www.cs.columbia.edu/CAVE/software/softlib/dorf.php
2011-04-27 11:58:34 +00:00
CCL_NAMESPACE_END
Copy Permalink