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
|
/* -*- C++ -*- */
// $Id$
// ============================================================================
//
// = LIBRARY
// ace
//
// = FILENAME
// Malloc_Base.h
//
// = AUTHOR
// Doug Schmidt and Irfan Pyarali
//
// ============================================================================
#ifndef ACE_MALLOC_BASE_H
#define ACE_MALLOC_BASE_H
#include "ace/pre.h"
// The definition of this class is located in Malloc.cpp.
class ACE_Export ACE_Allocator
{
// = TITLE
// Interface for a dynamic memory allocator that uses inheritance
// and dynamic binding to provide extensible mechanisms for
// allocating and deallocating memory.
public:
// = Memory Management
static ACE_Allocator *instance (void);
// Get pointer to a default <ACE_Allocator>.
static ACE_Allocator *instance (ACE_Allocator *);
// Set pointer to a process-wide <ACE_Allocator> and return existing
// pointer.
static void close_singleton (void);
// Delete the dynamically allocated Singleton
ACE_Allocator (void);
// "No-op" constructor (needed to make certain compilers happy).
virtual ~ACE_Allocator (void);
// Virtual destructor
virtual void *malloc (size_t nbytes) = 0;
// Allocate <nbytes>, but don't give them any initial value.
virtual void *calloc (size_t nbytes, char initial_value = '\0') = 0;
// Allocate <nbytes>, giving them <initial_value>.
virtual void free (void *ptr) = 0;
// Free <ptr> (must have been allocated by <ACE_Allocator::malloc>).
virtual int remove (void) = 0;
// Remove any resources associated with this memory manager.
// = Map manager like functions
virtual int bind (const char *name, void *pointer, int duplicates = 0) = 0;
// Associate <name> with <pointer>. If <duplicates> == 0 then do
// not allow duplicate <name>/<pointer> associations, else if
// <duplicates> != 0 then allow duplicate <name>/<pointer>
// assocations. Returns 0 if successfully binds (1) a previously
// unbound <name> or (2) <duplicates> != 0, returns 1 if trying to
// bind a previously bound <name> and <duplicates> == 0, else
// returns -1 if a resource failure occurs.
virtual int trybind (const char *name, void *&pointer) = 0;
// Associate <name> with <pointer>. Does not allow duplicate
// <name>/<pointer> associations. Returns 0 if successfully binds
// (1) a previously unbound <name>, 1 if trying to bind a previously
// bound <name>, or returns -1 if a resource failure occurs. When
// this call returns <pointer>'s value will always reference the
// void * that <name> is associated with. Thus, if the caller needs
// to use <pointer> (e.g., to free it) a copy must be maintained by
// the caller.
virtual int find (const char *name, void *&pointer) = 0;
// Locate <name> and pass out parameter via pointer. If found,
// return 0, Returns -1 if failure occurs.
virtual int find (const char *name) = 0;
// returns 0 if the name is in the mapping. -1, otherwise.
virtual int unbind (const char *name) = 0;
// Unbind (remove) the name from the map. Don't return the pointer
// to the caller
virtual int unbind (const char *name, void *&pointer) = 0;
// Break any association of name. Returns the value of pointer in
// case the caller needs to deallocate memory.
// = Protection and "sync" (i.e., flushing memory to persistent
// backing store).
virtual int sync (ssize_t len = -1, int flags = MS_SYNC) = 0;
// Sync <len> bytes of the memory region to the backing store
// starting at <this->base_addr_>. If <len> == -1 then sync the
// whole region.
virtual int sync (void *addr, size_t len, int flags = MS_SYNC) = 0;
// Sync <len> bytes of the memory region to the backing store
// starting at <addr_>.
virtual int protect (ssize_t len = -1, int prot = PROT_RDWR) = 0;
// Change the protection of the pages of the mapped region to <prot>
// starting at <this->base_addr_> up to <len> bytes. If <len> == -1
// then change protection of all pages in the mapped region.
virtual int protect (void *addr, size_t len, int prot = PROT_RDWR) = 0;
// Change the protection of the pages of the mapped region to <prot>
// starting at <addr> up to <len> bytes.
#if defined (ACE_HAS_MALLOC_STATS)
virtual void print_stats (void) const = 0;
// Dump statistics of how malloc is behaving.
#endif /* ACE_HAS_MALLOC_STATS */
virtual void dump (void) const = 0;
// Dump the state of the object.
private:
// DO NOT ADD ANY STATE (DATA MEMBERS) TO THIS CLASS!!!! See the
// <ACE_Allocator::instance> implementation for explanation.
static ACE_Allocator *allocator_;
// Pointer to a process-wide <ACE_Allocator> instance.
static int delete_allocator_;
// Must delete the <allocator_> if non-0.
};
#include "ace/post.h"
#endif /* ACE_MALLOC_BASE_H */
|
