2011-04-27 11:58:34 +00:00
|
|
|
/*
|
2013-08-18 14:16:15 +00:00
|
|
|
* Copyright 2011-2013 Blender Foundation
|
2011-04-27 11:58:34 +00:00
|
|
|
*
|
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
|
2011-04-27 11:58:34 +00:00
|
|
|
*
|
2013-08-18 14:16:15 +00:00
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
2011-04-27 11:58:34 +00:00
|
|
|
*
|
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
|
2014-12-25 01:50:24 +00:00
|
|
|
* limitations under the License.
|
2011-04-27 11:58:34 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef __DEVICE_MEMORY_H__
|
|
|
|
#define __DEVICE_MEMORY_H__
|
|
|
|
|
|
|
|
/* Device Memory
|
|
|
|
*
|
|
|
|
* This file defines data types that can be used in device memory arrays, and
|
|
|
|
* a device_vector<T> type to store such arrays.
|
|
|
|
*
|
|
|
|
* device_vector<T> contains an STL vector, metadata about the data type,
|
|
|
|
* dimensions, elements, and a device pointer. For the CPU device this is just
|
|
|
|
* a pointer to the STL vector data, as no copying needs to take place. For
|
|
|
|
* other devices this is a pointer to device memory, where we will copy memory
|
|
|
|
* to and from. */
|
|
|
|
|
Cycles: Make all #include statements relative to cycles source directory
The idea is to make include statements more explicit and obvious where the
file is coming from, additionally reducing chance of wrong header being
picked up.
For example, it was not obvious whether bvh.h was refferring to builder
or traversal, whenter node.h is a generic graph node or a shader node
and cases like that.
Surely this might look obvious for the active developers, but after some
time of not touching the code it becomes less obvious where file is coming
from.
This was briefly mentioned in T50824 and seems @brecht is fine with such
explicitness, but need to agree with all active developers before committing
this.
Please note that this patch is lacking changes related on GPU/OpenCL
support. This will be solved if/when we all agree this is a good idea to move
forward.
Reviewers: brecht, lukasstockner97, maiself, nirved, dingto, juicyfruit, swerner
Reviewed By: lukasstockner97, maiself, nirved, dingto
Subscribers: brecht
Differential Revision: https://developer.blender.org/D2586
2017-03-28 18:39:14 +00:00
|
|
|
#include "util/util_debug.h"
|
|
|
|
#include "util/util_half.h"
|
2017-10-20 21:31:13 +00:00
|
|
|
#include "util/util_texture.h"
|
Cycles: Make all #include statements relative to cycles source directory
The idea is to make include statements more explicit and obvious where the
file is coming from, additionally reducing chance of wrong header being
picked up.
For example, it was not obvious whether bvh.h was refferring to builder
or traversal, whenter node.h is a generic graph node or a shader node
and cases like that.
Surely this might look obvious for the active developers, but after some
time of not touching the code it becomes less obvious where file is coming
from.
This was briefly mentioned in T50824 and seems @brecht is fine with such
explicitness, but need to agree with all active developers before committing
this.
Please note that this patch is lacking changes related on GPU/OpenCL
support. This will be solved if/when we all agree this is a good idea to move
forward.
Reviewers: brecht, lukasstockner97, maiself, nirved, dingto, juicyfruit, swerner
Reviewed By: lukasstockner97, maiself, nirved, dingto
Subscribers: brecht
Differential Revision: https://developer.blender.org/D2586
2017-03-28 18:39:14 +00:00
|
|
|
#include "util/util_types.h"
|
|
|
|
#include "util/util_vector.h"
|
2011-04-27 11:58:34 +00:00
|
|
|
|
|
|
|
CCL_NAMESPACE_BEGIN
|
|
|
|
|
2017-05-07 12:40:58 +00:00
|
|
|
class Device;
|
|
|
|
|
2012-01-04 18:06:32 +00:00
|
|
|
enum MemoryType {
|
|
|
|
MEM_READ_ONLY,
|
|
|
|
MEM_WRITE_ONLY,
|
|
|
|
MEM_READ_WRITE
|
|
|
|
};
|
|
|
|
|
2011-04-27 11:58:34 +00:00
|
|
|
/* Supported Data Types */
|
|
|
|
|
|
|
|
enum DataType {
|
2017-09-26 21:42:36 +00:00
|
|
|
TYPE_UNKNOWN,
|
2011-04-27 11:58:34 +00:00
|
|
|
TYPE_UCHAR,
|
|
|
|
TYPE_UINT,
|
|
|
|
TYPE_INT,
|
2013-08-30 23:49:38 +00:00
|
|
|
TYPE_FLOAT,
|
2017-03-11 10:23:11 +00:00
|
|
|
TYPE_HALF,
|
|
|
|
TYPE_UINT64,
|
2011-04-27 11:58:34 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
static inline size_t datatype_size(DataType datatype)
|
|
|
|
{
|
|
|
|
switch(datatype) {
|
2017-09-26 21:42:36 +00:00
|
|
|
case TYPE_UNKNOWN: return 1;
|
2011-04-27 11:58:34 +00:00
|
|
|
case TYPE_UCHAR: return sizeof(uchar);
|
|
|
|
case TYPE_FLOAT: return sizeof(float);
|
|
|
|
case TYPE_UINT: return sizeof(uint);
|
|
|
|
case TYPE_INT: return sizeof(int);
|
2013-08-30 23:49:38 +00:00
|
|
|
case TYPE_HALF: return sizeof(half);
|
2017-03-11 10:23:11 +00:00
|
|
|
case TYPE_UINT64: return sizeof(uint64_t);
|
2011-04-27 11:58:34 +00:00
|
|
|
default: return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Traits for data types */
|
|
|
|
|
|
|
|
template<typename T> struct device_type_traits {
|
2017-09-26 21:42:36 +00:00
|
|
|
static const DataType data_type = TYPE_UNKNOWN;
|
|
|
|
static const int num_elements = sizeof(T);
|
2011-04-27 11:58:34 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
template<> struct device_type_traits<uchar> {
|
|
|
|
static const DataType data_type = TYPE_UCHAR;
|
|
|
|
static const int num_elements = 1;
|
|
|
|
};
|
|
|
|
|
|
|
|
template<> struct device_type_traits<uchar2> {
|
|
|
|
static const DataType data_type = TYPE_UCHAR;
|
|
|
|
static const int num_elements = 2;
|
|
|
|
};
|
|
|
|
|
|
|
|
template<> struct device_type_traits<uchar3> {
|
|
|
|
static const DataType data_type = TYPE_UCHAR;
|
|
|
|
static const int num_elements = 3;
|
|
|
|
};
|
|
|
|
|
|
|
|
template<> struct device_type_traits<uchar4> {
|
|
|
|
static const DataType data_type = TYPE_UCHAR;
|
|
|
|
static const int num_elements = 4;
|
|
|
|
};
|
|
|
|
|
|
|
|
template<> struct device_type_traits<uint> {
|
|
|
|
static const DataType data_type = TYPE_UINT;
|
|
|
|
static const int num_elements = 1;
|
|
|
|
};
|
|
|
|
|
|
|
|
template<> struct device_type_traits<uint2> {
|
|
|
|
static const DataType data_type = TYPE_UINT;
|
|
|
|
static const int num_elements = 2;
|
|
|
|
};
|
|
|
|
|
|
|
|
template<> struct device_type_traits<uint3> {
|
|
|
|
static const DataType data_type = TYPE_UINT;
|
|
|
|
static const int num_elements = 3;
|
|
|
|
};
|
|
|
|
|
|
|
|
template<> struct device_type_traits<uint4> {
|
|
|
|
static const DataType data_type = TYPE_UINT;
|
|
|
|
static const int num_elements = 4;
|
|
|
|
};
|
|
|
|
|
|
|
|
template<> struct device_type_traits<int> {
|
|
|
|
static const DataType data_type = TYPE_INT;
|
|
|
|
static const int num_elements = 1;
|
|
|
|
};
|
|
|
|
|
|
|
|
template<> struct device_type_traits<int2> {
|
|
|
|
static const DataType data_type = TYPE_INT;
|
|
|
|
static const int num_elements = 2;
|
|
|
|
};
|
|
|
|
|
|
|
|
template<> struct device_type_traits<int3> {
|
|
|
|
static const DataType data_type = TYPE_INT;
|
|
|
|
static const int num_elements = 3;
|
|
|
|
};
|
|
|
|
|
|
|
|
template<> struct device_type_traits<int4> {
|
|
|
|
static const DataType data_type = TYPE_INT;
|
|
|
|
static const int num_elements = 4;
|
|
|
|
};
|
|
|
|
|
|
|
|
template<> struct device_type_traits<float> {
|
|
|
|
static const DataType data_type = TYPE_FLOAT;
|
|
|
|
static const int num_elements = 1;
|
|
|
|
};
|
|
|
|
|
|
|
|
template<> struct device_type_traits<float2> {
|
|
|
|
static const DataType data_type = TYPE_FLOAT;
|
|
|
|
static const int num_elements = 2;
|
|
|
|
};
|
|
|
|
|
|
|
|
template<> struct device_type_traits<float3> {
|
|
|
|
static const DataType data_type = TYPE_FLOAT;
|
2017-05-07 12:40:58 +00:00
|
|
|
static const int num_elements = 4;
|
2011-04-27 11:58:34 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
template<> struct device_type_traits<float4> {
|
|
|
|
static const DataType data_type = TYPE_FLOAT;
|
|
|
|
static const int num_elements = 4;
|
|
|
|
};
|
|
|
|
|
2016-06-19 18:17:03 +00:00
|
|
|
template<> struct device_type_traits<half> {
|
|
|
|
static const DataType data_type = TYPE_HALF;
|
|
|
|
static const int num_elements = 1;
|
|
|
|
};
|
|
|
|
|
2013-08-30 23:49:38 +00:00
|
|
|
template<> struct device_type_traits<half4> {
|
|
|
|
static const DataType data_type = TYPE_HALF;
|
|
|
|
static const int num_elements = 4;
|
|
|
|
};
|
|
|
|
|
2017-03-11 10:23:11 +00:00
|
|
|
template<> struct device_type_traits<uint64_t> {
|
|
|
|
static const DataType data_type = TYPE_UINT64;
|
|
|
|
static const int num_elements = 1;
|
|
|
|
};
|
|
|
|
|
2011-04-27 11:58:34 +00:00
|
|
|
/* Device Memory */
|
|
|
|
|
|
|
|
class device_memory
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
size_t memory_size() { return data_size*data_elements*datatype_size(data_type); }
|
2017-05-07 12:40:58 +00:00
|
|
|
size_t memory_elements_size(int elements) {
|
|
|
|
return elements*data_elements*datatype_size(data_type);
|
|
|
|
}
|
2011-04-27 11:58:34 +00:00
|
|
|
|
|
|
|
/* data information */
|
|
|
|
DataType data_type;
|
|
|
|
int data_elements;
|
|
|
|
device_ptr data_pointer;
|
|
|
|
size_t data_size;
|
2014-09-04 11:22:40 +00:00
|
|
|
size_t device_size;
|
2011-04-27 11:58:34 +00:00
|
|
|
size_t data_width;
|
|
|
|
size_t data_height;
|
2014-03-29 12:03:48 +00:00
|
|
|
size_t data_depth;
|
2017-10-20 21:31:13 +00:00
|
|
|
MemoryType type;
|
|
|
|
const char *name;
|
|
|
|
InterpolationType interpolation;
|
|
|
|
ExtensionType extension;
|
2011-04-27 11:58:34 +00:00
|
|
|
|
|
|
|
/* device pointer */
|
2017-10-20 21:31:13 +00:00
|
|
|
Device *device;
|
2011-04-27 11:58:34 +00:00
|
|
|
device_ptr device_pointer;
|
|
|
|
|
2017-10-20 21:31:13 +00:00
|
|
|
device_memory(Device *device, const char *name, MemoryType type);
|
|
|
|
virtual ~device_memory();
|
2011-04-27 11:58:34 +00:00
|
|
|
|
2017-02-22 12:32:57 +00:00
|
|
|
void resize(size_t size)
|
|
|
|
{
|
|
|
|
data_size = size;
|
|
|
|
data_width = size;
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
2011-04-27 11:58:34 +00:00
|
|
|
/* no copying */
|
|
|
|
device_memory(const device_memory&);
|
|
|
|
device_memory& operator = (const device_memory&);
|
|
|
|
};
|
|
|
|
|
2017-05-07 12:40:58 +00:00
|
|
|
template<typename T>
|
|
|
|
class device_only_memory : public device_memory
|
|
|
|
{
|
|
|
|
public:
|
2017-10-20 21:31:13 +00:00
|
|
|
device_only_memory(Device *device, const char *name)
|
|
|
|
: device_memory(device, name, MEM_READ_WRITE)
|
2017-05-07 12:40:58 +00:00
|
|
|
{
|
|
|
|
data_type = device_type_traits<T>::data_type;
|
|
|
|
data_elements = max(device_type_traits<T>::num_elements, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
void resize(size_t num)
|
|
|
|
{
|
|
|
|
device_memory::resize(num*sizeof(T));
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2011-04-27 11:58:34 +00:00
|
|
|
/* Device Vector */
|
|
|
|
|
|
|
|
template<typename T> class device_vector : public device_memory
|
|
|
|
{
|
|
|
|
public:
|
2017-10-20 21:31:13 +00:00
|
|
|
device_vector(Device *device, const char *name, MemoryType type = MEM_READ_ONLY)
|
|
|
|
: device_memory(device, name, type)
|
2011-04-27 11:58:34 +00:00
|
|
|
{
|
|
|
|
data_type = device_type_traits<T>::data_type;
|
|
|
|
data_elements = device_type_traits<T>::num_elements;
|
|
|
|
|
|
|
|
assert(data_elements > 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual ~device_vector() {}
|
|
|
|
|
|
|
|
/* vector functions */
|
2014-03-29 12:03:48 +00:00
|
|
|
T *resize(size_t width, size_t height = 0, size_t depth = 0)
|
2011-04-27 11:58:34 +00:00
|
|
|
{
|
2014-03-29 12:03:48 +00:00
|
|
|
data_size = width * ((height == 0)? 1: height) * ((depth == 0)? 1: depth);
|
2015-09-04 07:38:10 +00:00
|
|
|
if(data.resize(data_size) == NULL) {
|
|
|
|
clear();
|
|
|
|
return NULL;
|
|
|
|
}
|
2011-04-27 11:58:34 +00:00
|
|
|
data_width = width;
|
|
|
|
data_height = height;
|
2014-03-29 12:03:48 +00:00
|
|
|
data_depth = depth;
|
2015-06-30 21:23:38 +00:00
|
|
|
if(data_size == 0) {
|
|
|
|
data_pointer = 0;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
data_pointer = (device_ptr)&data[0];
|
2011-04-27 11:58:34 +00:00
|
|
|
return &data[0];
|
|
|
|
}
|
|
|
|
|
2017-10-20 02:32:29 +00:00
|
|
|
void steal_data(array<T>& from)
|
2011-04-27 11:58:34 +00:00
|
|
|
{
|
2017-10-20 02:32:29 +00:00
|
|
|
data.steal_data(from);
|
|
|
|
data_size = data.size();
|
|
|
|
data_pointer = (data_size)? (device_ptr)&data[0]: 0;
|
|
|
|
data_width = data_size;
|
|
|
|
data_height = 0;
|
|
|
|
data_depth = 0;
|
2011-04-27 11:58:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void clear()
|
|
|
|
{
|
|
|
|
data.clear();
|
|
|
|
data_pointer = 0;
|
|
|
|
data_width = 0;
|
|
|
|
data_height = 0;
|
2014-03-29 12:03:48 +00:00
|
|
|
data_depth = 0;
|
2011-04-27 11:58:34 +00:00
|
|
|
data_size = 0;
|
2017-02-22 12:32:57 +00:00
|
|
|
device_pointer = 0;
|
2011-04-27 11:58:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
size_t size()
|
|
|
|
{
|
|
|
|
return data.size();
|
|
|
|
}
|
|
|
|
|
2014-10-03 08:52:04 +00:00
|
|
|
T* get_data()
|
|
|
|
{
|
|
|
|
return &data[0];
|
|
|
|
}
|
|
|
|
|
2017-10-20 02:32:29 +00:00
|
|
|
T& operator[](size_t i)
|
|
|
|
{
|
|
|
|
return data[i];
|
|
|
|
}
|
|
|
|
|
2011-04-27 11:58:34 +00:00
|
|
|
private:
|
|
|
|
array<T> data;
|
|
|
|
};
|
|
|
|
|
2017-05-07 12:40:58 +00:00
|
|
|
/* A device_sub_ptr is a pointer into another existing memory.
|
|
|
|
* Therefore, it is not allocated separately, but just created from the already allocated base memory.
|
|
|
|
* It is freed automatically when it goes out of scope, which should happen before the base memory is freed.
|
|
|
|
* Note that some devices require the offset and size of the sub_ptr to be properly aligned. */
|
|
|
|
class device_sub_ptr
|
|
|
|
{
|
|
|
|
public:
|
2017-10-20 21:31:13 +00:00
|
|
|
device_sub_ptr(device_memory& mem, int offset, int size);
|
2017-05-07 12:40:58 +00:00
|
|
|
~device_sub_ptr();
|
|
|
|
/* No copying. */
|
|
|
|
device_sub_ptr& operator = (const device_sub_ptr&);
|
|
|
|
|
|
|
|
device_ptr operator*() const
|
|
|
|
{
|
|
|
|
return ptr;
|
|
|
|
}
|
|
|
|
protected:
|
|
|
|
Device *device;
|
|
|
|
device_ptr ptr;
|
|
|
|
};
|
|
|
|
|
2011-04-27 11:58:34 +00:00
|
|
|
CCL_NAMESPACE_END
|
|
|
|
|
|
|
|
#endif /* __DEVICE_MEMORY_H__ */
|
|
|
|
|