1/* This file is part of the Vc library. {{{
2Copyright © 2014 Matthias Kretz <kretz@kde.org>
4Redistribution and use in source and binary forms, with or without
5modification, are permitted provided that the following conditions are met:
6 * Redistributions of source code must retain the above copyright
7 notice, this list of conditions and the following disclaimer.
8 * Redistributions in binary form must reproduce the above copyright
9 notice, this list of conditions and the following disclaimer in the
10 documentation and/or other materials provided with the distribution.
11 * Neither the names of contributing organizations nor the
12 names of its contributors may be used to endorse or promote products
13 derived from this software without specific prior written permission.
15THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
16ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
17WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
18DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
19DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
20(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
21LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
22ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
24SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28#ifndef VC_ALLOCATOR_H_
29#define VC_ALLOCATOR_H_
37#include "common/macros.h"
42 * Convenience macro to set the default allocator for a given \p Type to
45 * \param Type Your type that you want to use with STL containers.
47 * \note You have to use this macro in the global namespace.
50#define Vc_DECLARE_ALLOCATOR(Type) \
53template <> class allocator<Type> : public ::Vc::Allocator<Type> \
56 template <typename U> struct rebind { \
57 typedef ::std::allocator<U> other; \
59 /* MSVC brokenness: the following function is optional - just doesn't compile \
61 const allocator &select_on_container_copy_construction() const { return *this; } \
65#define Vc_DECLARE_ALLOCATOR(Type) \
68template <> class allocator<Type> : public ::Vc::Allocator<Type> \
71 template <typename U> struct rebind { \
72 typedef ::std::allocator<U> other; \
78namespace Vc_VERSIONED_NAMESPACE
84 * \headerfile Allocator <Vc/Allocator>
85 * An allocator that uses global new and supports over-aligned types, as per [C++11 20.6.9].
87 * Meant as a simple replacement for the allocator defined in the C++ Standard.
88 * Allocation is done using the global new/delete operators. But if the alignment property of \p
89 * T is larger than the size of a pointer, the allocate function allocates slightly more memory
90 * to adjust the pointer for correct alignment.
92 * If the \p T does not require over-alignment no additional memory will be allocated.
94 * \tparam T The type of objects to allocate.
99 * Vc::float_v x, y, z;
104 * std::vector<Data> dat0; // this will use std::allocator<Data>, which probably ignores the
105 * // alignment requirements for Data. Thus any access to dat0 may
106 * // crash your program.
108 * std::vector<Data, Vc::Allocator<Data> > dat1; // now std::vector will get correctly aligned
109 * // memory. Accesses to dat1 are safe.
113 * %Vc ships a macro to conveniently tell STL to use Vc::Allocator per default for a given type:
116 * Vc::float_v x, y, z;
118 * Vc_DECLARE_ALLOCATOR(Data)
122 * std::vector<Data> dat0; // good now
128 template<typename T> class Allocator
132#ifdef Vc_HAVE_STD_MAX_ALIGN_T
133 NaturalAlignment = alignof(std::max_align_t),
134#elif defined(Vc_HAVE_MAX_ALIGN_T)
135 NaturalAlignment = alignof(::max_align_t),
137 NaturalAlignment = sizeof(void *) > alignof(long double) ? sizeof(void *) :
138 (alignof(long double) > alignof(long long) ? alignof(long double) : alignof(long long)),
140#if defined Vc_IMPL_AVX
142#elif defined Vc_IMPL_SSE
147 Alignment = alignof(T) > SimdAlignment ? alignof(T) : SimdAlignment,
148 /* The number of extra bytes allocated must be large enough to put a pointer right
149 * before the adjusted address. This pointer stores the original address, which is
150 * required to call ::operator delete in deallocate.
152 * The address we get from ::operator new is a multiple of NaturalAlignment:
153 * p = N * NaturalAlignment
155 * Since all alignments are powers of two, Alignment is a multiple of NaturalAlignment:
156 * Alignment = k * NaturalAlignment
159 * 1. If p is already aligned to Alignment then allocate will return p + Alignment. In
160 * this case there are Alignment Bytes available to store a pointer.
161 * 2. If p is not aligned then p + (k - (N modulo k)) * NaturalAlignment will be
162 * returned. Since NaturalAlignment >= sizeof(void*) the pointer fits.
164 ExtraBytes = Alignment > NaturalAlignment ? Alignment : 0,
165 AlignmentMask = Alignment - 1
168 typedef size_t size_type;
169 typedef ptrdiff_t difference_type;
171 typedef const T* const_pointer;
172 typedef T& reference;
173 typedef const T& const_reference;
174 typedef T value_type;
176 template<typename U> struct rebind { typedef Allocator<U> other; };
178 Allocator() throw() { }
179 Allocator(const Allocator&) throw() { }
180 template<typename U> Allocator(const Allocator<U>&) throw() { }
182 pointer address(reference x) const { return &x; }
183 const_pointer address(const_reference x) const { return &x; }
185 pointer allocate(size_type n, const void* = 0)
187 if (n > this->max_size()) {
188 throw std::bad_alloc();
191 char *p = static_cast<char *>(::operator new(n * sizeof(T) + ExtraBytes));
192 if (ExtraBytes > 0) {
195 const char *null = 0;
196 p -= ((p - null) & AlignmentMask); // equivalent to p &= ~AlignmentMask;
197 reinterpret_cast<char **>(p)[-1] = pp;
199 return reinterpret_cast<pointer>(p);
202 void deallocate(pointer p, size_type)
204 if (ExtraBytes > 0) {
205 p = reinterpret_cast<pointer *>(p)[-1];
207 ::operator delete(p);
210 size_type max_size() const throw() { return size_t(-1) / sizeof(T); }
213 // MSVC brokenness: the following function is optional - just doesn't compile without it
214 const Allocator &select_on_container_copy_construction() const { return *this; }
216 // MSVC also requires a function that neither C++98 nor C++11 mention
217 // but it doesn't support variadic templates... otherwise the Vc_CXX11 clause would be nice
218 void construct(pointer p) { ::new(p) T(); }
220 // we still need the C++98 version:
221 void construct(pointer p, const T& val) { ::new(p) T(val); }
222 void destroy(pointer p) { p->~T(); }
224 template<typename U, typename... Args> void construct(U* p, Args&&... args)
226 ::new(p) U(std::forward<Args>(args)...);
228 template<typename U> void destroy(U* p) { p->~U(); }
232 template<typename T> inline bool operator==(const Allocator<T>&, const Allocator<T>&) { return true; }
233 template<typename T> inline bool operator!=(const Allocator<T>&, const Allocator<T>&) { return false; }
240 template<typename T, typename Abi>
241 class allocator<Vc::Vector<T, Abi> > : public ::Vc::Allocator<Vc::Vector<T, Abi> >
244 template<typename U> struct rebind { typedef ::std::allocator<U> other; };
246 // MSVC brokenness: the following function is optional - just doesn't compile without it
247 const allocator &select_on_container_copy_construction() const { return *this; }
250 template <typename T, typename Abi>
251 class allocator<Vc::Mask<T, Abi>> : public ::Vc::Allocator<Vc::Mask<T, Abi>>
254 template<typename U> struct rebind { typedef ::std::allocator<U> other; };
256 // MSVC brokenness: the following function is optional - just doesn't compile without it
257 const allocator &select_on_container_copy_construction() const { return *this; }
260 template <typename T, std::size_t N, typename V, std::size_t M>
261 class allocator<Vc::SimdArray<T, N, V, M>> : public ::Vc::Allocator<Vc::SimdArray<T, N, V, M>>
264 template<typename U> struct rebind { typedef ::std::allocator<U> other; };
266 // MSVC brokenness: the following function is optional - just doesn't compile without it
267 const allocator &select_on_container_copy_construction() const { return *this; }
270 template <typename T, std::size_t N, typename V, std::size_t M>
271 class allocator<Vc::SimdMaskArray<T, N, V, M>> : public ::Vc::Allocator<Vc::SimdMaskArray<T, N, V, M>>
274 template<typename U> struct rebind { typedef ::std::allocator<U> other; };
276 // MSVC brokenness: the following function is optional - just doesn't compile without it
277 const allocator &select_on_container_copy_construction() const { return *this; }
282#endif // VC_ALLOCATOR_H_
284// vim: ft=cpp et sw=4 sts=4