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
|
// -*- C++ -*-
//==========================================================================
/**
* @file Malloc_Allocator.h
*
* $Id$
*
* @author Based on code that formerly existed in another ACE file.
*/
//==========================================================================
#ifndef ACE_MALLOC_ALLOCATOR_H
#define ACE_MALLOC_ALLOCATOR_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/Malloc_Base.h"
#if defined (ACE_HAS_MALLOC_STATS)
#if defined (ACE_HAS_THREADS)
#include "ace/Process_Mutex.h"
#define ACE_PROCESS_MUTEX ACE_Process_Mutex
#else
#include "ace/SV_Semaphore_Simple.h"
#define ACE_PROCESS_MUTEX ACE_SV_Semaphore_Simple
#endif /* ACE_HAS_THREADS */
#endif /* ACE_HAS_MALLOC_STATS */
/**
* @class ACE_New_Allocator
*
* @brief Defines a class that provided a simple implementation of
* memory allocation.
*
* This class uses the new/delete operators to allocate and free up
* memory. Please note that the only methods that are supported are
* <malloc>, <calloc>, and <free>. All other methods are no-ops that
* return -1 and set <errno> to <ENOTSUP>. If you require this
* functionality, please use: ACE_Allocator_Adapter <ACE_Malloc
* <ACE_LOCAL_MEMORY_POOL, MUTEX> >, which will allow you to use the
* added functionality of bind/find/etc. while using the new/delete
* operators.
*/
class ACE_Export ACE_New_Allocator : public ACE_Allocator
{
public:
/// These methods are defined.
virtual void *malloc (size_t nbytes);
virtual void *calloc (size_t nbytes, char initial_value = '\0');
virtual void *calloc (size_t n_elem, size_t elem_size, char initial_value = '\0');
virtual void free (void *ptr);
/// These methods are no-ops.
virtual int remove (void);
virtual int bind (const char *name, void *pointer, int duplicates = 0);
virtual int trybind (const char *name, void *&pointer);
virtual int find (const char *name, void *&pointer);
virtual int find (const char *name);
virtual int unbind (const char *name);
virtual int unbind (const char *name, void *&pointer);
virtual int sync (ssize_t len = -1, int flags = MS_SYNC);
virtual int sync (void *addr, size_t len, int flags = MS_SYNC);
virtual int protect (ssize_t len = -1, int prot = PROT_RDWR);
virtual int protect (void *addr, size_t len, int prot = PROT_RDWR);
#if defined (ACE_HAS_MALLOC_STATS)
virtual void print_stats (void) const;
#endif /* ACE_HAS_MALLOC_STATS */
virtual void dump (void) const;
private:
// DO NOT ADD ANY STATE (DATA MEMBERS) TO THIS CLASS!!!! See the
// <ACE_Allocator::instance> implementation for explanation.
};
/**
* @class ACE_Static_Allocator_Base
*
* @brief Defines a class that provided a highly optimized memory
* management scheme for allocating memory statically.
*
* This class manages a fixed-size <POOL_SIZE> of memory. Every
* time <malloc>/<calloc> is called, it simply moves an internal
* index forward and returns a pointer to the requested chunk.
* All memory is allocated statically (typically via the
* <ACE_Static_Allocator> template) and <free> is a no-op. This
* behavior is useful for use-cases where all the memory
* allocation needs are known in advance and no deletions ever
* occur.
*/
class ACE_Export ACE_Static_Allocator_Base : public ACE_Allocator
{
public:
ACE_Static_Allocator_Base (char *buffer, size_t size);
virtual void *malloc (size_t nbytes);
virtual void *calloc (size_t nbytes, char initial_value = '\0');
virtual void *calloc (size_t n_elem, size_t elem_size, char initial_value = '\0');
virtual void free (void *ptr);
virtual int remove (void);
virtual int bind (const char *name, void *pointer, int duplicates = 0);
virtual int trybind (const char *name, void *&pointer);
virtual int find (const char *name, void *&pointer);
virtual int find (const char *name);
virtual int unbind (const char *name);
virtual int unbind (const char *name, void *&pointer);
virtual int sync (ssize_t len = -1, int flags = MS_SYNC);
virtual int sync (void *addr, size_t len, int flags = MS_SYNC);
virtual int protect (ssize_t len = -1, int prot = PROT_RDWR);
virtual int protect (void *addr, size_t len, int prot = PROT_RDWR);
#if defined (ACE_HAS_MALLOC_STATS)
virtual void print_stats (void) const;
#endif /* ACE_HAS_MALLOC_STATS */
virtual void dump (void) const;
protected:
/// Don't allow direct instantiations of this class.
ACE_Static_Allocator_Base (void);
/// Pointer to the buffer.
char *buffer_;
/// Size of the buffer.
size_t size_;
/// Pointer to the current offset in the <buffer_>.
size_t offset_;
};
#if defined (__ACE_INLINE__)
#include "ace/Malloc_Allocator.inl"
#endif /* __ACE_INLINE__ */
#include /**/ "ace/post.h"
#endif /* MALLOC_ALLOCATOR_H */
|
