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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
|
// -*- C++ -*-
//=============================================================================
/**
* @file OS_Memory.h
*
* @author Doug Schmidt <d.schmidt@vanderbilt.edu>
* @author Jesper S. M|ller<stophph@diku.dk>
* @author and a cast of thousands...
*/
//=============================================================================
#ifndef ACE_OS_MEMORY_H
#define ACE_OS_MEMORY_H
#include /**/ "ace/pre.h"
#include /**/ "ace/ACE_export.h"
#if !defined (ACE_LACKS_PRAGMA_ONCE)
# pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */
#include "ace/OS_Errno.h"
#include "ace/Basic_Types.h"
#include "ace/os_include/os_stddef.h"
// Allow an installation to replace the lowest-level allocation
// functions without changing the source of ACE.
//
// To do this, simple #define ACE_*_FUNC macros in config.h to
// the names of the site-specific functions, e.g.,
//
// #define ACE_MALLOC_FUNC dlmalloc
// #define ACE_CALLOC_FUNC dlcalloc
// #define ACE_FREE_FUNC dlfree
// #define ACE_REALLOC_FUNC dlrealloc
//
// For completeness' sake, you should probably put
// #define ACE_HAS_STRDUP_EMULATION
// #define ACE_HAS_WCSDUP_EMULATION
// too, so that you guarantee that strdup() and wcsdup() call your
// desired mallocator and not the system mallocator.
//
#if !defined (ACE_MALLOC_FUNC)
# define ACE_MALLOC_FUNC ::malloc
#endif
#if !defined (ACE_CALLOC_FUNC)
# define ACE_CALLOC_FUNC ::calloc
#endif
#if !defined (ACE_FREE_FUNC)
# define ACE_FREE_FUNC ::free
#endif
#if !defined (ACE_REALLOC_FUNC)
# define ACE_REALLOC_FUNC ::realloc
#endif
ACE_BEGIN_VERSIONED_NAMESPACE_DECL
typedef void * ACE_MALLOC_T;
ACE_END_VERSIONED_NAMESPACE_DECL
// ============================================================================
// ACE_NEW macros
//
// A useful abstraction for expressions involving operator new since
// we can change memory allocation error handling policies (e.g.,
// depending on whether ANSI/ISO exception handling semantics are
// being used).
// ============================================================================
// The Windows MFC exception mechanism requires that a caught CException
// (including the CMemoryException in use here) be freed using its Delete()
// method. Thus, when MFC is in use and we're catching exceptions as a result
// of new(), the exception's Delete() method has to be called. No other
// platform imposes this sort of restriction/requirement. The Windows
// config stuff (at least for MSVC/MFC) defines a ACE_del_bad_alloc macro
// that works with its ACE_bad_alloc macro to implement this cleanup
// requirement. Since no other platform requires this, define it as
// empty here.
#if !defined (ACE_del_bad_alloc)
# define ACE_del_bad_alloc
#endif
// For backwards compatibility, we except all compilers to support these
#include /**/ <new>
#define ACE_bad_alloc std::bad_alloc
#define ACE_nothrow std::nothrow
#define ACE_nothrow_t std::nothrow_t
// Since new() throws exceptions, we need a way to avoid passing
// exceptions past the call to new because ACE counts on having a 0
// return value for a failed allocation. Some compilers offer the
// new (nothrow) version, which does exactly what we want. Others
// do not. For those that do not, this sets up what exception is thrown,
// and then below we'll do a try/catch around the new to catch it and
// return a 0 pointer instead.
# if defined (__HP_aCC)
# define ACE_throw_bad_alloc throw ACE_bad_alloc ()
# elif defined (__SUNPRO_CC)
# define ACE_throw_bad_alloc throw ACE_bad_alloc ()
# elif defined (ACE_USES_STD_NAMESPACE_FOR_STDCPP_LIB)
# if defined (ACE_HAS_MFC) && (ACE_HAS_MFC == 1)
# define ACE_throw_bad_alloc AfxThrowMemoryException ()
# else
# define ACE_throw_bad_alloc throw ACE_bad_alloc ()
# endif
# else
// MFC changes the behavior of operator new at all MSVC versions from 6 up.
# if defined (ACE_HAS_MFC) && (ACE_HAS_MFC == 1)
# define ACE_throw_bad_alloc AfxThrowMemoryException ()
# else
# define ACE_throw_bad_alloc throw ACE_bad_alloc ()
# endif
# endif /* __HP_aCC */
#define ACE_NEW_RETURN(POINTER,CONSTRUCTOR,RET_VAL) \
do { POINTER = new (std::nothrow) CONSTRUCTOR; \
if (POINTER == 0) { errno = ENOMEM; return RET_VAL; } \
} while (0)
#define ACE_NEW(POINTER,CONSTRUCTOR) \
do { POINTER = new(std::nothrow) CONSTRUCTOR; \
if (POINTER == 0) { errno = ENOMEM; return; } \
} while (0)
#define ACE_NEW_NORETURN(POINTER,CONSTRUCTOR) \
do { POINTER = new(std::nothrow) CONSTRUCTOR; \
if (POINTER == 0) { errno = ENOMEM; } \
} while (0)
ACE_BEGIN_VERSIONED_NAMESPACE_DECL
//@{
/**
* @name Efficiently compute aligned pointers to powers of 2 boundaries.
*/
/**
* Efficiently align "value" up to "alignment", knowing that all such
* boundaries are binary powers and that we're using two's complement
* arithmetic.
*
* Since the alignment is a power of two its binary representation is:
*
* alignment = 0...010...0
*
* hence
*
* alignment - 1 = 0...001...1 = T1
*
* so the complement is:
*
* ~(alignment - 1) = 1...110...0 = T2
*
* Notice that there is a multiple of @a alignment in the range
* [<value>,<value> + T1], also notice that if
*
* X = ( <value> + T1 ) & T2
*
* then
*
* <value> <= X <= <value> + T1
*
* because the & operator only changes the last bits, and since X is a
* multiple of @a alignment (its last bits are zero) we have found the
* multiple we wanted.
*/
/// Return the next integer aligned to a required boundary
/**
* @param ptr the base pointer
* @param alignment the required alignment
*/
#if defined (ACE_OPENVMS) && (!defined (__INITIAL_POINTER_SIZE) || (__INITIAL_POINTER_SIZE < 64))
inline unsigned int
ACE_align_binary (unsigned int ptr, unsigned int alignment)
{
unsigned int const tmp = alignment - 1;
return (ptr + tmp) & (~tmp);
}
#else
inline uintptr_t
ACE_align_binary (uintptr_t ptr, uintptr_t alignment)
{
uintptr_t const tmp = alignment - 1;
return (ptr + tmp) & (~tmp);
}
#endif
#if defined (ACE_OPENVMS) && (!defined (__INITIAL_POINTER_SIZE) || (__INITIAL_POINTER_SIZE < 64))
/// Return the next address aligned to a required boundary
inline char *
ACE_ptr_align_binary (char const * ptr, unsigned int alignment)
{
return
reinterpret_cast<char *> (
ACE_align_binary (reinterpret_cast<unsigned int> (ptr), alignment));
}
/// Return the next address aligned to a required boundary
inline char *
ACE_ptr_align_binary (unsigned char const * ptr, unsigned int alignment)
{
return
ACE_ptr_align_binary (reinterpret_cast<char const *> (ptr), alignment);
}
#else
/// Return the next address aligned to a required boundary
inline char *
ACE_ptr_align_binary (char const * ptr, uintptr_t alignment)
{
return
reinterpret_cast<char *> (
ACE_align_binary (reinterpret_cast<uintptr_t> (ptr), alignment));
}
/// Return the next address aligned to a required boundary
inline char *
ACE_ptr_align_binary (unsigned char const * ptr, uintptr_t alignment)
{
return
ACE_ptr_align_binary (reinterpret_cast<char const *> (ptr), alignment);
}
#endif /* ACE_OPENVMS && __INITIAL_POINTER_SIZE < 64 */
//@}
ACE_END_VERSIONED_NAMESPACE_DECL
#include "ace/OS_NS_stdlib.h"
#include /**/ "ace/post.h"
#endif /* ACE_OS_MEMORY_H */
|
