griefith/test
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
54d69a2fd1be60aaba62f92cd0db5b5ba71495aa
test/intern/cycles/util/vector.h

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

60 lines
1.7 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
Cleanup: Fix Cycles Apache header. This was already mixed a bit, but the dot belongs there.
2014-12-25 02:50:24 +01:00
* 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
*/
#ifndef __UTIL_VECTOR_H__
#define __UTIL_VECTOR_H__
Cycles: Add assert to an array at() function to be sure we don't have bad memory access
2015-06-28 11:18:48 +02:00
#include <cassert>
#include <cstring>
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 <vector>
Cycles: remove prefix from source code file names Remove prefix of filenames that is the same as the folder name. This used to help when #includes were using individual files, but now they are always relative to the cycles root directory and so the prefixes are redundant. For patches and branches, git merge and rebase should be able to detect the renames and move over code to the right file.
2021-10-24 14:19:19 +02:00
#include "util/aligned_malloc.h"
#include "util/guarded_allocator.h"
#include "util/types.h"
Cycles: ensure any SSE data is allocated 16 byte aligned, happens automatically on many platforms but is not assured everywhere.
2013-06-22 14:35:09 +00:00
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_BEGIN
Cleanup: spelling
2019-08-17 00:54:22 +10:00
/* Own subclass-ed version of std::vector. Subclass is needed because:
Cycles: Implement guarded allocator for STL classes The commit implements a guarded allocator which can be used by STL classes such as vectors, maps and so on. This allocator will keep track of current and peak memory usage which then can be queried. New code for allocator is only active when building Cycles with debug flag (WITH_CYCLES_DEBUG) and doesn't distort regular builds too much. Additionally now we're using own subclass of std::vector which allows us to implement shrink_to_fit() method which would ensure capacity of the vector is as big as it should be (without this making vector smaller will still use all previous memory allocated).
2015-02-14 18:03:39 +05:00
*
Cycles: Always use guarded allocator of vectors We don't have vectors re-allocation happening multiple times from inside a loop anymore, so we can safely switch to a memory guarded allocator for vectors and keep track on the memory usage at various stages of rendering. Additionally, when building from inside Blender repository, Cycles will use Blender's guarded allocator, so actual memory usage will be displayed in the Space Info header. There are couple of tricky aspects of the patch: - TaskScheduler::exit() now explicitly frees memory used by `threads`. This is needed because `threads` is a static member which destructor isn't getting called on Blender's exit which caused memory leak print to happen. This shouldn't give any measurable speed issues, reallocation of that vector is only one of fewzillion other allocations happening during synchronization. - Use regular guarded malloc (not aligned one). No idea why it was made to be aligned in the first place. Perhaps some corner case tests or so. Vector was never expected to be aligned anyway. Let's see if we'll have actual bugs with this. Reviewers: dingto, lukasstockner97, juicyfruit, brecht Reviewed By: brecht Differential Revision: https://developer.blender.org/D1774
2016-02-07 03:40:41 +05:00
* - Use own allocator which keeps track of used/peak memory.
Cycles: Implement guarded allocator for STL classes The commit implements a guarded allocator which can be used by STL classes such as vectors, maps and so on. This allocator will keep track of current and peak memory usage which then can be queried. New code for allocator is only active when building Cycles with debug flag (WITH_CYCLES_DEBUG) and doesn't distort regular builds too much. Additionally now we're using own subclass of std::vector which allows us to implement shrink_to_fit() method which would ensure capacity of the vector is as big as it should be (without this making vector smaller will still use all previous memory allocated).
2015-02-14 18:03:39 +05:00
* - Have method to ensure capacity is re-set to 0.
*/
Cycles: Always use guarded allocator of vectors We don't have vectors re-allocation happening multiple times from inside a loop anymore, so we can safely switch to a memory guarded allocator for vectors and keep track on the memory usage at various stages of rendering. Additionally, when building from inside Blender repository, Cycles will use Blender's guarded allocator, so actual memory usage will be displayed in the Space Info header. There are couple of tricky aspects of the patch: - TaskScheduler::exit() now explicitly frees memory used by `threads`. This is needed because `threads` is a static member which destructor isn't getting called on Blender's exit which caused memory leak print to happen. This shouldn't give any measurable speed issues, reallocation of that vector is only one of fewzillion other allocations happening during synchronization. - Use regular guarded malloc (not aligned one). No idea why it was made to be aligned in the first place. Perhaps some corner case tests or so. Vector was never expected to be aligned anyway. Let's see if we'll have actual bugs with this. Reviewers: dingto, lukasstockner97, juicyfruit, brecht Reviewed By: brecht Differential Revision: https://developer.blender.org/D1774
2016-02-07 03:40:41 +05:00
template<typename value_type, typename allocator_type = GuardedAllocator<value_type>>
Cycles: Allow using custom allocators for vector class
2015-06-26 22:36:31 +02:00
class vector : public std::vector<value_type, allocator_type> {
Cycles: Implement guarded allocator for STL classes The commit implements a guarded allocator which can be used by STL classes such as vectors, maps and so on. This allocator will keep track of current and peak memory usage which then can be queried. New code for allocator is only active when building Cycles with debug flag (WITH_CYCLES_DEBUG) and doesn't distort regular builds too much. Additionally now we're using own subclass of std::vector which allows us to implement shrink_to_fit() method which would ensure capacity of the vector is as big as it should be (without this making vector smaller will still use all previous memory allocated).
2015-02-14 18:03:39 +05:00
public:
Cycles: Cleanup, remove unneeded method from vector Since we've defaulted to C++11, no need to override this method manually anymore.
2018-11-09 11:37:56 +01:00
typedef std::vector<value_type, allocator_type> BaseClass;
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cycles: Cleanup, remove unneeded manual constructors specification
2018-11-09 11:44:33 +01:00
/* Inherit all constructors from base class. */
using BaseClass::vector;
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cycles: Cleanup, some documentation
2018-11-09 11:46:09 +01:00
/* Try as hard as possible to use zero memory. */
Cycles: Cleanup, don't use strict C prototypes Those are more like a legacy of language, which is not needed in C++.
2018-11-09 12:01:38 +01:00
void free_memory()
Cycles: Allow using custom allocators for vector class
2015-06-26 22:36:31 +02:00
{
Fix T87793: Cycles OptiX crash hiding objects in viewport render
2021-05-19 00:55:22 +02:00
vector<value_type, allocator_type> empty;
BaseClass::swap(empty);
Cycles: Add utility method to vector which totally frees memory used the vector The method is called vector::free_memory(). Use with care since it'll invalidate all the pointers to vector memory, all iterators and so on. Currently unused, but might become handy when clearing unused data.
2015-02-14 20:49:20 +05:00
}
ClangFormat: apply to source, most of intern Apply clang format as proposed in T53211. For details on usage and instructions for migrating branches without conflicts, see: https://wiki.blender.org/wiki/Tools/ClangFormat
2019-04-17 06:17:24 +02:00
Cycles: Implement guarded allocator for STL classes The commit implements a guarded allocator which can be used by STL classes such as vectors, maps and so on. This allocator will keep track of current and peak memory usage which then can be queried. New code for allocator is only active when building Cycles with debug flag (WITH_CYCLES_DEBUG) and doesn't distort regular builds too much. Additionally now we're using own subclass of std::vector which allows us to implement shrink_to_fit() method which would ensure capacity of the vector is as big as it should be (without this making vector smaller will still use all previous memory allocated).
2015-02-14 18:03:39 +05:00
/* Some external API might demand working with std::vector. */
operator std::vector<value_type>()
{
Fix T47427: Crash caused by OSL
2016-02-16 13:37:05 +01:00
return std::vector<value_type>(this->begin(), this->end());
Cycles: Implement guarded allocator for STL classes The commit implements a guarded allocator which can be used by STL classes such as vectors, maps and so on. This allocator will keep track of current and peak memory usage which then can be queried. New code for allocator is only active when building Cycles with debug flag (WITH_CYCLES_DEBUG) and doesn't distort regular builds too much. Additionally now we're using own subclass of std::vector which allows us to implement shrink_to_fit() method which would ensure capacity of the vector is as big as it should be (without this making vector smaller will still use all previous memory allocated).
2015-02-14 18:03:39 +05:00
}
};
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
#endif /* __UTIL_VECTOR_H__ */
Reference in New Issue Copy Permalink