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
|
/*
* Copyright (c) 2016-2017, NVIDIA CORPORATION. All rights reserved.
*
* NVIDIA CORPORATION and its licensors retain all intellectual property
* and proprietary rights in and to this software, related documentation
* and any modifications thereto. Any use, reproduction, disclosure or
* distribution of this software and related documentation without an express
* license agreement from NVIDIA CORPORATION is strictly prohibited.
*/
#ifndef NVBLASTEXTALLOCATOR_H
#define NVBLASTEXTALLOCATOR_H
#include "NvBlastTkFramework.h"
#include "PxAllocatorCallback.h"
namespace Nv
{
namespace Blast
{
/**
ExtAllocator uses TkFramework allocator
*/
class ExtAllocator
{
public:
ExtAllocator(const char* = 0)
{
}
void* allocate(size_t size, const char* filename, int line)
{
return NvBlastTkFrameworkGet()->getAllocatorCallback().allocate(size, nullptr, filename, line);
}
void deallocate(void* ptr)
{
NvBlastTkFrameworkGet()->getAllocatorCallback().deallocate(ptr);
}
/**
Aligned allocation.
Example using 16-byte alignment:
// b will lie on a 16-byte boundary and point to 50 bytes of usable memory
void* b = alignedAlloc<16>(50);
*/
template<int A>
static void* alignedAlloc(size_t size, const char* filename, int line)
{
NV_COMPILE_TIME_ASSERT(A > 0 && A <= 256);
unsigned char* mem = (unsigned char*)ExtAllocator().allocate(size + A, filename, line);
const unsigned char offset = (unsigned char)((uintptr_t)A - (uintptr_t)mem % A - 1);
mem += offset;
*mem++ = offset;
return mem;
}
template<int A>
static void* alignedAlloc(size_t size)
{
return alignedAlloc<A>(size, __FILE__, __LINE__);
}
/**
Version of alignedAlloc specialized 16-byte aligned allocation.
*/
static void* alignedAlloc16(size_t size)
{
return alignedAlloc<16>(size);
}
/**
Aligned deallocation.
Memory freed using this function MUST have been allocated using alignedAlloc.
Example using free:
// Using the memory pointer b from the example above (for alignedAlloc)
alignedFree(b);
*/
static void alignedFree(void* block)
{
if (block != nullptr)
{
unsigned char* mem = (unsigned char*)block;
const unsigned char offset = *--mem;
ExtAllocator().deallocate(mem - offset);
}
};
};
/**
ExtAlignedAllocator uses ExtAllocator
*/
template<int A>
class ExtAlignedAllocator
{
public:
ExtAlignedAllocator(const char* = 0)
{
}
void* allocate(size_t size, const char* filename, int line)
{
return ExtAllocator::alignedAlloc<A>(size, filename, line);
}
void deallocate(void* ptr)
{
return ExtAllocator::alignedFree(ptr);
}
};
} // namespace Blast
} // namespace Nv
#endif // #ifndef NVBLASTEXTALLOCATOR_H
|