{{ message }}
forked from boostorg/interprocess
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathmanaged_shared_memory_test.cpp
More file actions
270 lines (223 loc) · 7.86 KB
/
Copy pathmanaged_shared_memory_test.cpp
File metadata and controls
270 lines (223 loc) · 7.86 KB
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
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
//////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga 2004-2012. Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/interprocess for documentation.
//
//////////////////////////////////////////////////////////////////////////////
#include <boost/interprocess/allocators/allocator.hpp>
#include <boost/container/vector.hpp>
#include <boost/interprocess/managed_shared_memory.hpp>
#include <cstdio>
#include <string>
#include "get_process_id_name.hpp"
using namespace boost::interprocess;
template <class CharT>
struct filename_traits;
template <>
struct filename_traits<char>
{
static const char* get()
{ return test::get_process_id_name(); }
static std::string filename;
};
#ifdef BOOST_INTERPROCESS_WCHAR_NAMED_RESOURCES
template <>
struct filename_traits<wchar_t>
{
static const wchar_t* get()
{ return test::get_process_id_wname(); }
static std::wstring filename;
};
#endif //#ifdef BOOST_INTERPROCESS_WCHAR_NAMED_RESOURCES
template<class CharT>
int test_managed_shared_memory()
{
const int ShmemSize = 65536;
const CharT *const ShmemName = filename_traits<CharT>::get();
//STL compatible allocator object for memory-mapped shmem
typedef allocator<int, managed_shared_memory::segment_manager>
allocator_int_t;
//A vector that uses that allocator
typedef boost::container::vector<int, allocator_int_t> MyVect;
{
//Remove the shmem it is already created
shared_memory_object::remove(ShmemName);
const int max = 100;
void *array[std::size_t(max)];
//Named allocate capable shared memory allocator
managed_shared_memory shmem(create_only, ShmemName, ShmemSize);
std::size_t i;
//Let's allocate some memory
for(i = 0; i < max; ++i){
array[std::ptrdiff_t(i)] = shmem.allocate(i+1u);
}
//Deallocate allocated memory
for(i = 0; i < max; ++i){
shmem.deallocate(array[std::ptrdiff_t(i)]);
}
}
{
//Remove the shmem it is already created
shared_memory_object::remove(ShmemName);
//Named allocate capable memory mapped shmem managed memory class
managed_shared_memory tmp(create_only, ShmemName, ShmemSize);
}
{
//Remove the shmem it is already created
shared_memory_object::remove(ShmemName);
//Now re-create it with create or open
managed_shared_memory shmem(open_or_create, ShmemName, ShmemSize);
//Construct the STL-like allocator with the segment manager
const allocator_int_t myallocator (shmem.get_segment_manager());
//Construct vector
MyVect *shmem_vect = shmem.construct<MyVect> ("MyVector") (myallocator);
//Test that vector can be found via name
if(shmem_vect != shmem.find<MyVect>("MyVector").first)
return -1;
//Destroy and check it is not present
shmem.destroy<MyVect> ("MyVector");
if(0 != shmem.find<MyVect>("MyVector").first)
return -1;
//Construct a vector in the memory-mapped shmem
shmem_vect = shmem.construct<MyVect> ("MyVector") (myallocator);
}
{
//Map preexisting shmem again in memory
managed_shared_memory shmem(open_only, ShmemName);
//Check vector is still there
MyVect *shmem_vect = shmem.find<MyVect>("MyVector").first;
if(!shmem_vect)
return -1;
}
{
{
//Map preexisting shmem again in copy-on-write
managed_shared_memory shmem(open_copy_on_write, ShmemName);
//Check vector is still there
MyVect *shmem_vect = shmem.find<MyVect>("MyVector").first;
if(!shmem_vect)
return -1;
//Erase vector
shmem.destroy_ptr(shmem_vect);
//Make sure vector is erased
shmem_vect = shmem.find<MyVect>("MyVector").first;
if(shmem_vect)
return -1;
}
//Now check vector is still in the shmem
{
//Map preexisting shmem again in copy-on-write
managed_shared_memory shmem(open_copy_on_write, ShmemName);
//Check vector is still there
MyVect *shmem_vect = shmem.find<MyVect>("MyVector").first;
if(!shmem_vect)
return -1;
}
{
//Map preexisting shmem again in memory
managed_shared_memory shmem(open_or_create, ShmemName, ShmemSize);
//Check vector is still there
MyVect *shmem_vect = shmem.find<MyVect>("MyVector").first;
if(!shmem_vect)
return -1;
}
}
{
//Map preexisting shmem again in read-only
managed_shared_memory shmem(open_read_only, ShmemName);
//Check vector is still there
MyVect *shmem_vect = shmem.find<MyVect>("MyVector").first;
if(!shmem_vect)
return -1;
}
#ifndef BOOST_INTERPROCESS_POSIX_SHARED_MEMORY_OBJECTS_NO_GROW
{
managed_shared_memory::size_type old_free_memory;
{
//Map preexisting shmem again in memory
managed_shared_memory shmem(open_only, ShmemName);
old_free_memory = shmem.get_free_memory();
}
//Now grow the shmem
managed_shared_memory::grow(ShmemName, ShmemSize);
//Map preexisting shmem again in memory
managed_shared_memory shmem(open_only, ShmemName);
//Check vector is still there
MyVect *shmem_vect = shmem.find<MyVect>("MyVector").first;
if(!shmem_vect)
return -1;
if(shmem.get_size() != (ShmemSize*2))
return -1;
if(shmem.get_free_memory() <= old_free_memory)
return -1;
}
{
managed_shared_memory::size_type old_free_memory, next_free_memory,
old_shmem_size, next_shmem_size, final_shmem_size;
{
//Map preexisting shmem again in memory
managed_shared_memory shmem(open_only, ShmemName);
old_free_memory = shmem.get_free_memory();
old_shmem_size = shmem.get_size();
}
//Now shrink the shmem
managed_shared_memory::shrink_to_fit(ShmemName);
{
//Map preexisting shmem again in memory
managed_shared_memory shmem(open_only, ShmemName);
next_shmem_size = shmem.get_size();
//Check vector is still there
MyVect *shmem_vect = shmem.find<MyVect>("MyVector").first;
if(!shmem_vect)
return -1;
next_free_memory = shmem.get_free_memory();
if(next_free_memory >= old_free_memory)
return -1;
if(old_shmem_size <= next_shmem_size)
return -1;
}
//Now destroy the vector
{
//Map preexisting shmem again in memory
managed_shared_memory shmem(open_only, ShmemName);
//Destroy and check it is not present
shmem.destroy<MyVect>("MyVector");
if(0 != shmem.find<MyVect>("MyVector").first)
return -1;
}
//Now shrink the shmem
managed_shared_memory::shrink_to_fit(ShmemName);
{
//Map preexisting shmem again in memory
managed_shared_memory shmem(open_only, ShmemName);
final_shmem_size = shmem.get_size();
if(next_shmem_size <= final_shmem_size)
return -1;
}
}
#endif //ifndef BOOST_INTERPROCESS_POSIX_SHARED_MEMORY_OBJECTS_NO_GROW
{
//Now test move semantics
managed_shared_memory original(open_only, ShmemName);
managed_shared_memory move_ctor(boost::move(original));
managed_shared_memory move_assign;
move_assign = boost::move(move_ctor);
move_assign.swap(original);
}
shared_memory_object::remove(ShmemName);
return 0;
}
int main ()
{
int r;
r = test_managed_shared_memory<char>();
if(r) return r;
#ifdef BOOST_INTERPROCESS_WCHAR_NAMED_RESOURCES
r = test_managed_shared_memory<wchar_t>();
if(r) return r;
#endif
return 0;
}
You can’t perform that action at this time.