1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
|
#ifndef SLANG_CORE_ALLOCATOR_H
#define SLANG_CORE_ALLOCATOR_H
#include "slang-common.h"
#include <stdlib.h>
#ifdef _MSC_VER
# include <malloc.h>
#endif
#include <type_traits>
namespace Slang
{
inline void* alignedAllocate(size_t size, size_t alignment)
{
#ifdef _MSC_VER
return _aligned_malloc(size, alignment);
#elif defined(__CYGWIN__)
return aligned_alloc(alignment, size);
#else
void* rs = nullptr;
int succ = posix_memalign(&rs, alignment, size);
return (succ == 0) ? rs : nullptr;
#endif
}
inline void alignedDeallocate(void* ptr)
{
#ifdef _MSC_VER
_aligned_free(ptr);
#else
free(ptr);
#endif
}
class StandardAllocator
{
public:
// not really called
void* allocate(size_t size)
{
return ::malloc(size);
}
void deallocate(void * ptr)
{
return ::free(ptr);
}
};
template<int ALIGNMENT>
class AlignedAllocator
{
public:
void* allocate(size_t size)
{
return alignedAllocate(size, ALIGNMENT);
}
void deallocate(void * ptr)
{
return alignedDeallocate(ptr);
}
};
// Helper utilties for calling allocators.
template<typename T, int isPOD>
class Initializer;
template<typename T>
class Initializer<T, 0>
{
public:
static void initialize(T* buffer, Index size)
{
for (Index i = 0; i < size; i++)
new (buffer + i) T();
}
};
template<typename T>
class Initializer<T, 1>
{
public:
static void initialize(T* buffer, Index size)
{
SLANG_UNUSED(buffer);
SLANG_UNUSED(size);
// It's pod so no initialization required
//for (int i = 0; i < size; i++)
// new (buffer + i) T;
}
};
template<typename T, typename TAllocator>
class AllocateMethod
{
public:
static inline T* allocateArray(Index count)
{
TAllocator allocator;
T* rs = (T*)allocator.allocate(count * sizeof(T));
Initializer<T, std::is_pod<T>::value>::initialize(rs, count);
return rs;
}
static inline void deallocateArray(T* ptr, Index count)
{
TAllocator allocator;
if (!std::is_trivially_destructible<T>::value)
{
for (Index i = 0; i < count; i++)
ptr[i].~T();
}
allocator.deallocate(ptr);
}
};
#if 0
template<typename T>
class AllocateMethod<T, StandardAllocator>
{
public:
static inline T* allocateArray(Index count)
{
return new T[count];
}
static inline void deallocateArray(T* ptr, Index /*bufferSize*/)
{
delete[] ptr;
}
};
#endif
}
#endif
|
