Merged revision(s) 58452-58584 from trunk/blender into soc-2013-dingto.
[blender-staging.git] / intern / cycles / util / util_vector.h
1 /*
2  * Copyright 2011, Blender Foundation.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  */
18
19 #ifndef __UTIL_VECTOR_H__
20 #define __UTIL_VECTOR_H__
21
22 /* Vector */
23
24 #include <string.h>
25 #include <vector>
26
27 #include "util_types.h"
28
29 CCL_NAMESPACE_BEGIN
30
31 using std::vector;
32
33 static inline void *malloc_aligned(size_t size, size_t alignment)
34 {
35         void *data = (void*)malloc(size + sizeof(void*) + alignment - 1);
36
37         union { void *ptr; size_t offset; } u;
38         u.ptr = (char*)data + sizeof(void*);
39         u.offset = (u.offset + alignment - 1) & ~(alignment - 1);
40         *(((void**)u.ptr) - 1) = data;
41
42         return u.ptr;
43 }
44
45 static inline void free_aligned(void *ptr)
46 {
47         if(ptr) {
48                 void *data = *(((void**)ptr) - 1);
49                 free(data);
50         }
51 }
52
53 /* Array
54  *
55  * Simplified version of vector, serving multiple purposes:
56  * - somewhat faster in that it does not clear memory on resize/alloc,
57  *   this was actually showing up in profiles quite significantly. it
58  *   also does not run any constructors/destructors
59  * - if this is used, we are not tempted to use inefficient operations
60  * - aligned allocation for SSE data types */
61
62 template<typename T, size_t alignment = 16>
63 class array
64 {
65 public:
66         array()
67         {
68                 data = NULL;
69                 datasize = 0;
70         }
71
72         array(size_t newsize)
73         {
74                 if(newsize == 0) {
75                         data = NULL;
76                         datasize = 0;
77                 }
78                 else {
79                         data = (T*)malloc_aligned(sizeof(T)*newsize, alignment);
80                         datasize = newsize;
81                 }
82         }
83
84         array(const array& from)
85         {
86                 *this = from;
87         }
88
89         array& operator=(const array& from)
90         {
91                 if(from.datasize == 0) {
92                         data = NULL;
93                         datasize = 0;
94                 }
95                 else {
96                         data = (T*)malloc_aligned(sizeof(T)*from.datasize, alignment);
97                         memcpy(data, from.data, from.datasize*sizeof(T));
98                         datasize = from.datasize;
99                 }
100
101                 return *this;
102         }
103
104         array& operator=(const vector<T>& from)
105         {
106                 datasize = from.size();
107                 data = NULL;
108
109                 if(datasize > 0) {
110                         data = (T*)malloc_aligned(sizeof(T)*datasize, alignment);
111                         memcpy(data, &from[0], datasize*sizeof(T));
112                         free_aligned(data);
113                         data = (T*)malloc_aligned(sizeof(T)*datasize, alignment);
114                         memcpy(data, &from[0], datasize*sizeof(T));
115                 }
116
117                 return *this;
118         }
119
120         ~array()
121         {
122                 free_aligned(data);
123         }
124
125         void resize(size_t newsize)
126         {
127                 if(newsize == 0) {
128                         clear();
129                 }
130                 else if(newsize != datasize) {
131                         T *newdata = (T*)malloc_aligned(sizeof(T)*newsize, alignment);
132                         memcpy(newdata, data, ((datasize < newsize)? datasize: newsize)*sizeof(T));
133                         free_aligned(data);
134
135                         data = newdata;
136                         datasize = newsize;
137                 }
138         }
139
140         void clear()
141         {
142                 free_aligned(data);
143                 data = NULL;
144                 datasize = 0;
145         }
146
147         size_t size() const
148         {
149                 return datasize;
150         }
151
152         T& operator[](size_t i) const
153         {
154                 return data[i];
155         }
156
157 protected:
158         T *data;
159         size_t datasize;
160 };
161
162 CCL_NAMESPACE_END
163
164 #endif /* __UTIL_VECTOR_H__ */
165