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
|
// -*- C++ -*-
//=============================================================================
/**
* @file Pagefile_Memory_Pool.h
*
* @author Dougls C. Schmidt <d.schmidt@vanderbilt.edu>
* @author Prashant Jain <pjain@cs.wustl.edu>
*/
//=============================================================================
#ifndef ACE_PAGEFILE_MEMORY_POOL_H
#define ACE_PAGEFILE_MEMORY_POOL_H
#include /**/ "ace/pre.h"
#include /**/ "ace/ACE_export.h"
#if !defined (ACE_LACKS_PRAGMA_ONCE)
# pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */
#if defined (ACE_WIN32)
#include "ace/ACE.h"
#include "ace/os_include/sys/os_mman.h"
ACE_BEGIN_VERSIONED_NAMESPACE_DECL
/**
* @class ACE_Pagefile_Memory_Pool_Options
*
* @brief Helper class for Pagefile Memory Pool constructor options.
*
* This should be a nested class, but that breaks too many
* compilers.
*/
class ACE_Export ACE_Pagefile_Memory_Pool_Options
{
public:
/// Initialization method.
ACE_Pagefile_Memory_Pool_Options (
void *base_addr = ACE_DEFAULT_PAGEFILE_POOL_BASE,
size_t max_size = ACE_DEFAULT_PAGEFILE_POOL_SIZE);
/// Base address of the memory-mapped backing store.
void *base_addr_;
/// Maximum size the pool may grow.
size_t max_size_;
};
/**
* @class ACE_Pagefile_Memory_Pool
*
* @brief Make a memory pool that is based on "anonymous" memory
* regions allocated from the Win32 page file.
*/
class ACE_Export ACE_Pagefile_Memory_Pool
{
public:
typedef ACE_Pagefile_Memory_Pool_Options OPTIONS;
/// Initialize the pool.
ACE_Pagefile_Memory_Pool (const ACE_TCHAR *backing_store_name = 0,
const OPTIONS *options = 0);
/// Destructor
virtual ~ACE_Pagefile_Memory_Pool () = default;
/// Ask system for initial chunk of shared memory.
void *init_acquire (size_t nbytes,
size_t &rounded_bytes,
int &first_time);
/// Acquire at least @a nbytes from the memory pool. <rounded_bytes>
/// is the actual number of bytes allocated.
void *acquire (size_t nbytes,
size_t &rounded_bytes);
/// Instruct the memory pool to release all of its resources.
int release (int destroy = 1);
/**
* Win32 Structural exception selector. The return value decides
* how to handle memory pool related structural exceptions. Returns
* 1, 0, or , -1.
*/
virtual int seh_selector (void *);
/**
* Try to extend the virtual address space so that @a addr is now
* covered by the address mapping. The method succeeds and returns
* 0 if the backing store has adequate memory to cover this address.
* Otherwise, it returns -1. This method is typically called by an
* exception handler for a Win32 structured exception when another
* process has grown the backing store (and its mapping) and our
* process now incurs a fault because our mapping isn't in range
* (yet).
*/
int remap (void *addr);
/// Round up to system page size.
size_t round_to_page_size (size_t nbytes);
/// Round up to the chunk size required by the operation system
size_t round_to_chunk_size (size_t nbytes);
// = Don't need this methods here ...
int sync (ssize_t = -1, int = MS_SYNC);
int sync (void *, size_t, int = MS_SYNC);
int protect (ssize_t = -1, int = PROT_RDWR);
int protect (void *, size_t, int = PROT_RDWR);
/// Return the base address of this memory pool, 0 if base_addr
/// never changes.
virtual void *base_addr () const;
void dump () const {}
protected:
/**
* Map portions or the entire pool into the local virtual address
* space. To do this, we compute the new @c file_offset of the
* backing store and commit the memory.
*/
int map (int &firstTime, size_t appendBytes = 0);
/// Release the mapping.
int unmap ();
private:
/**
* @class Control_Block
*
* @brief Attributes that are meaningful in local storage only.
*/
class Control_Block
{
public:
/// Required base address
void *req_base_;
/// Base address returned from system call
void *mapped_base_;
/**
* @class Shared_Control_Block
*
* @brief Pool statistics
*/
class Shared_Control_Block
{
public:
/// Maximum size the pool may grow
size_t max_size_;
/// Size of mapped shared memory segment
size_t mapped_size_;
/// Offset to mapped but not yet acquired address space
ptrdiff_t free_offset_;
/// Size of mapped but not yet acquired address space
size_t free_size_;
};
Shared_Control_Block sh_;
};
// Base of mapped region. If this has the value of 0 then the OS is
// free to select any address to map the file, otherwise this value
// is what the OS must try to use to mmap the file.
/// Description of what our process mapped.
Control_Block local_cb_;
/// Shared memory pool statistics.
Control_Block *shared_cb_;
/// File mapping handle.
ACE_HANDLE object_handle_;
/// System page size.
size_t page_size_;
/// Name of the backing store where the shared memory pool is kept.
ACE_TCHAR backing_store_name_[MAXPATHLEN];
};
ACE_END_VERSIONED_NAMESPACE_DECL
#endif /* ACE_WIN32 */
#if defined (__ACE_INLINE__)
#include "ace/Pagefile_Memory_Pool.inl"
#endif /* __ACE_INLINE__ */
#include /**/ "ace/post.h"
#endif /* ACE_MEMORY_POOL_H */
|
