From: igaztanaga_at_[hidden]
Date: 2007-09-26 13:46:35
Author: igaztanaga
Date: 2007-09-26 13:46:34 EDT (Wed, 26 Sep 2007)
New Revision: 39552
URL: http://svn.boost.org/trac/boost/changeset/39552
Log:
Changes introduced by the new intrusive version.
Text files modified:
trunk/libs/interprocess/test/check_equal_containers.hpp | 2
trunk/libs/interprocess/test/memory_algorithm_test_template.hpp | 501 ++++++++++++++++++---------------------
trunk/libs/interprocess/test/node_pool_test.cpp | 11
trunk/libs/interprocess/test/shared_ptr_test.cpp | 1
trunk/libs/interprocess/test/unique_ptr_test.cpp | 13
5 files changed, 236 insertions(+), 292 deletions(-)
Modified: trunk/libs/interprocess/test/check_equal_containers.hpp
==============================================================================
--- trunk/libs/interprocess/test/check_equal_containers.hpp (original)
+++ trunk/libs/interprocess/test/check_equal_containers.hpp 2007-09-26 13:46:34 EDT (Wed, 26 Sep 2007)
@@ -32,7 +32,7 @@
typename MyShmCont::iterator itshm(shmcont->begin()), itshmend(shmcont->end());
typename MyStdCont::iterator itstd(stdcont->begin());
- if((typename MyShmCont::size_type)std::distance(itshm, itshmend) != shmcont->size()){
+ if((typename MyStdCont::size_type)std::distance(itshm, itshmend) != shmcont->size()){
return false;
}
for(; itshm != itshmend; ++itshm, ++itstd){
Modified: trunk/libs/interprocess/test/memory_algorithm_test_template.hpp
==============================================================================
--- trunk/libs/interprocess/test/memory_algorithm_test_template.hpp (original)
+++ trunk/libs/interprocess/test/memory_algorithm_test_template.hpp 2007-09-26 13:46:34 EDT (Wed, 26 Sep 2007)
@@ -20,77 +20,64 @@
namespace boost { namespace interprocess { namespace test {
+enum deallocation_type { DirectDeallocation, InverseDeallocation, MixedDeallocation, EndDeallocationType };
+
//This test allocates until there is no more memory
//and after that deallocates all in the inverse order
template<class Allocator>
-bool test_allocation_inverse_deallocation(Allocator &a)
+bool test_allocation(Allocator &a)
{
- std::vector<void*> buffers;
-
- for(int i = 0; true; ++i){
- void *ptr = a.allocate(i, std::nothrow);
- if(!ptr)
- break;
- buffers.push_back(ptr);
- }
-
- for(int j = (int)buffers.size()
- ;j--
- ;){
- a.deallocate(buffers[j]);
- }
-
- return a.all_memory_deallocated() && a.check_sanity();
-}
+ for( deallocation_type t = DirectDeallocation
+ ; t != EndDeallocationType
+ ; t = (deallocation_type)((int)t + 1)){
+ std::vector<void*> buffers;
+ std::size_t free_memory = a.get_free_memory();
-//This test allocates until there is no more memory
-//and after that deallocates all in the same order
-template<class Allocator>
-bool test_allocation_direct_deallocation(Allocator &a)
-{
- std::vector<void*> buffers;
- std::size_t free_memory = a.get_free_memory();
+ for(int i = 0; true; ++i){
+ void *ptr = a.allocate(i, std::nothrow);
+ if(!ptr)
+ break;
+ buffers.push_back(ptr);
+ }
- for(int i = 0; true; ++i){
- void *ptr = a.allocate(i, std::nothrow);
- if(!ptr)
+ switch(t){
+ case DirectDeallocation:
+ {
+ for(int j = 0, max = (int)buffers.size()
+ ;j < max
+ ;++j){
+ a.deallocate(buffers[j]);
+ }
+ }
break;
- buffers.push_back(ptr);
- }
-
- for(int j = 0, max = (int)buffers.size()
- ;j < max
- ;++j){
- a.deallocate(buffers[j]);
- }
-
- return free_memory == a.get_free_memory() &&
- a.all_memory_deallocated() && a.check_sanity();
-}
-
-//This test allocates until there is no more memory
-//and after that deallocates all following a pattern
-template<class Allocator>
-bool test_allocation_mixed_deallocation(Allocator &a)
-{
- std::vector<void*> buffers;
-
- for(int i = 0; true; ++i){
- void *ptr = a.allocate(i, std::nothrow);
- if(!ptr)
+ case InverseDeallocation:
+ {
+ for(int j = (int)buffers.size()
+ ;j--
+ ;){
+ a.deallocate(buffers[j]);
+ }
+ }
break;
- buffers.push_back(ptr);
- }
-
- for(int j = 0, max = (int)buffers.size()
- ;j < max
- ;++j){
- int pos = (j%4)*((int)buffers.size())/4;
- a.deallocate(buffers[pos]);
- buffers.erase(buffers.begin()+pos);
+ case MixedDeallocation:
+ {
+ for(int j = 0, max = (int)buffers.size()
+ ;j < max
+ ;++j){
+ int pos = (j%4)*((int)buffers.size())/4;
+ a.deallocate(buffers[pos]);
+ buffers.erase(buffers.begin()+pos);
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ bool ok = free_memory == a.get_free_memory() &&
+ a.all_memory_deallocated() && a.check_sanity();
+ if(!ok) return ok;
}
-
- return a.all_memory_deallocated() && a.check_sanity();
+ return true;
}
//This test allocates until there is no more memory
@@ -524,98 +511,106 @@
//This test allocates multiple values until there is no more memory
//and after that deallocates all in the inverse order
template<class Allocator>
-bool test_many_equal_allocation_inverse_deallocation(Allocator &a)
+bool test_many_equal_allocation(Allocator &a)
{
typedef typename Allocator::multiallocation_iterator multiallocation_iterator;
+ for( deallocation_type t = DirectDeallocation
+ ; t != EndDeallocationType
+ ; t = (deallocation_type)((int)t + 1)){
+ std::size_t free_memory = a.get_free_memory();
- std::vector<void*> buffers;
- for(int i = 0; true; ++i){
- std::size_t received_size;
- multiallocation_iterator it = a.allocate_many(i+1, i+1, (i+1)*2, received_size, std::nothrow);
- if(!it)
- break;
- multiallocation_iterator itend;
+ std::vector<void*> buffers2;
- for(; it != itend; ++it){
- buffers.push_back(*it);
+ //Allocate buffers with extra memory
+ for(int i = 0; true; ++i){
+ void *ptr = a.allocate(i, std::nothrow);
+ if(!ptr)
+ break;
+ buffers2.push_back(ptr);
}
- }
- for(int j = (int)buffers.size()
- ;j--
- ;){
- a.deallocate(buffers[j]);
- }
+ //Now deallocate the half of the blocks
+ //so expand maybe can merge new free blocks
+ for(int i = 0, max = (int)buffers2.size()
+ ;i < max
+ ;++i){
+ if(i%2){
+ a.deallocate(buffers2[i]);
+ buffers2[i] = 0;
+ }
+ }
- return a.all_memory_deallocated() && a.check_sanity();
-}
+ std::vector<void*> buffers;
+ for(int i = 0; true; ++i){
+ multiallocation_iterator it = a.allocate_many(i+1, (i+1)*2, std::nothrow);
+ if(!it)
+ break;
+ multiallocation_iterator itend;
-//This test allocates multiple values until there is no more memory
-//and after that deallocates all in the same order
-template<class Allocator>
-bool test_many_equal_allocation_direct_deallocation(Allocator &a)
-{
- typedef typename Allocator::multiallocation_iterator multiallocation_iterator;
- std::vector<void*> buffers;
- std::size_t free_memory = a.get_free_memory();
+ std::size_t n = 0;
+ for(; it != itend; ++n){
+ buffers.push_back(*it++);
+ }
+ if(n != std::size_t((i+1)*2))
+ return false;
+ }
- for(int i = 0; true; ++i){
- std::size_t received_size;
- multiallocation_iterator it = a.allocate_many(i+1, i+1, (i+1)*2, received_size, std::nothrow);
- if(!it)
+ switch(t){
+ case DirectDeallocation:
+ {
+ for(int j = 0, max = (int)buffers.size()
+ ;j < max
+ ;++j){
+ a.deallocate(buffers[j]);
+ }
+ }
+ break;
+ case InverseDeallocation:
+ {
+ for(int j = (int)buffers.size()
+ ;j--
+ ;){
+ a.deallocate(buffers[j]);
+ }
+ }
+ break;
+ case MixedDeallocation:
+ {
+ for(int j = 0, max = (int)buffers.size()
+ ;j < max
+ ;++j){
+ int pos = (j%4)*((int)buffers.size())/4;
+ a.deallocate(buffers[pos]);
+ buffers.erase(buffers.begin()+pos);
+ }
+ }
+ break;
+ default:
break;
- multiallocation_iterator itend;
-
- for(; it != itend; ++it){
- buffers.push_back(*it);
}
- }
- for(int j = 0, max = (int)buffers.size()
- ;j < max
- ;++j){
- a.deallocate(buffers[j]);
- }
-
- return free_memory == a.get_free_memory() &&
- a.all_memory_deallocated() && a.check_sanity();
-}
-
-//This test allocates multiple values until there is no more memory
-//and after that deallocates all following a pattern
-template<class Allocator>
-bool test_many_equal_allocation_mixed_deallocation(Allocator &a)
-{
- typedef typename Allocator::multiallocation_iterator multiallocation_iterator;
- std::vector<void*> buffers;
-
- for(int i = 0; true; ++i){
- std::size_t received_size;
- multiallocation_iterator it = a.allocate_many(i+1, i+1, (i+1)*2, received_size, std::nothrow);
- if(!it)
- break;
- multiallocation_iterator itend;
+ //Deallocate the rest of the blocks
- for(; it != itend; ++it){
- buffers.push_back(*it);
+ //Deallocate it in non sequential order
+ for(int j = 0, max = (int)buffers2.size()
+ ;j < max
+ ;++j){
+ int pos = (j%4)*((int)buffers2.size())/4;
+ a.deallocate(buffers2[pos]);
+ buffers2.erase(buffers2.begin()+pos);
}
- }
- for(int j = 0, max = (int)buffers.size()
- ;j < max
- ;++j){
- int pos = (j%4)*((int)buffers.size())/4;
- a.deallocate(buffers[pos]);
- buffers.erase(buffers.begin()+pos);
+ bool ok = free_memory == a.get_free_memory() &&
+ a.all_memory_deallocated() && a.check_sanity();
+ if(!ok) return ok;
}
-
- return a.all_memory_deallocated() && a.check_sanity();
+ return true;
}
//This test allocates multiple values until there is no more memory
//and after that deallocates all in the inverse order
template<class Allocator>
-bool test_many_different_allocation_inverse_deallocation(Allocator &a)
+bool test_many_different_allocation(Allocator &a)
{
typedef typename Allocator::multiallocation_iterator multiallocation_iterator;
const std::size_t ArraySize = 11;
@@ -624,178 +619,125 @@
requested_sizes[i] = 4*i;
}
- std::vector<void*> buffers;
- for(int i = 0; true; ++i){
- multiallocation_iterator it = a.allocate_many(requested_sizes, ArraySize, 1, std::nothrow);
- if(!it)
- break;
- multiallocation_iterator itend;
+ for( deallocation_type t = DirectDeallocation
+ ; t != EndDeallocationType
+ ; t = (deallocation_type)((int)t + 1)){
+ std::size_t free_memory = a.get_free_memory();
- for(; it != itend; ++it){
- buffers.push_back(*it);
- }
- }
+ std::vector<void*> buffers2;
- for(int j = (int)buffers.size()
- ;j--
- ;){
- a.deallocate(buffers[j]);
- }
+ //Allocate buffers with extra memory
+ for(int i = 0; true; ++i){
+ void *ptr = a.allocate(i, std::nothrow);
+ if(!ptr)
+ break;
+ buffers2.push_back(ptr);
+ }
- return a.all_memory_deallocated() && a.check_sanity();
-}
+ //Now deallocate the half of the blocks
+ //so expand maybe can merge new free blocks
+ for(int i = 0, max = (int)buffers2.size()
+ ;i < max
+ ;++i){
+ if(i%2){
+ a.deallocate(buffers2[i]);
+ buffers2[i] = 0;
+ }
+ }
-//This test allocates multiple values until there is no more memory
-//and after that deallocates all in the same order
-template<class Allocator>
-bool test_many_different_allocation_direct_deallocation(Allocator &a)
-{
- std::size_t free_memory = a.get_free_memory();
- typedef typename Allocator::multiallocation_iterator multiallocation_iterator;
- const std::size_t ArraySize = 11;
- std::size_t requested_sizes[ArraySize];
- for(std::size_t i = 0; i < ArraySize; ++i){
- requested_sizes[i] = 4*i;
- }
+ std::vector<void*> buffers;
+ for(int i = 0; true; ++i){
+ multiallocation_iterator it = a.allocate_many(requested_sizes, ArraySize, 1, std::nothrow);
+ if(!it)
+ break;
+ multiallocation_iterator itend;
+ std::size_t n = 0;
+ for(; it != itend; ++n){
+ buffers.push_back(*it++);
+ }
+ if(n != ArraySize)
+ return false;
+ }
- std::vector<void*> buffers;
- for(int i = 0; true; ++i){
- multiallocation_iterator it = a.allocate_many(requested_sizes, ArraySize, 1, std::nothrow);
- if(!it)
+ switch(t){
+ case DirectDeallocation:
+ {
+ for(int j = 0, max = (int)buffers.size()
+ ;j < max
+ ;++j){
+ a.deallocate(buffers[j]);
+ }
+ }
+ break;
+ case InverseDeallocation:
+ {
+ for(int j = (int)buffers.size()
+ ;j--
+ ;){
+ a.deallocate(buffers[j]);
+ }
+ }
+ break;
+ case MixedDeallocation:
+ {
+ for(int j = 0, max = (int)buffers.size()
+ ;j < max
+ ;++j){
+ int pos = (j%4)*((int)buffers.size())/4;
+ a.deallocate(buffers[pos]);
+ buffers.erase(buffers.begin()+pos);
+ }
+ }
+ break;
+ default:
break;
- multiallocation_iterator itend;
-
- for(; it != itend; ++it){
- buffers.push_back(*it);
}
- }
-
- for(int j = 0, max = (int)buffers.size()
- ;j < max
- ;++j){
- a.deallocate(buffers[j]);
- }
-
- return free_memory == a.get_free_memory() &&
- a.all_memory_deallocated() && a.check_sanity();
-}
-
-//This test allocates multiple values until there is no more memory
-//and after that deallocates all following a pattern
-template<class Allocator>
-bool test_many_different_allocation_mixed_deallocation(Allocator &a)
-{
- typedef typename Allocator::multiallocation_iterator multiallocation_iterator;
- const std::size_t ArraySize = 11;
- std::size_t requested_sizes[ArraySize];
- for(std::size_t i = 0; i < ArraySize; ++i){
- requested_sizes[i] = 4*i;
- }
- std::vector<void*> buffers;
- for(int i = 0; true; ++i){
- multiallocation_iterator it = a.allocate_many(requested_sizes, ArraySize, 1, std::nothrow);
- if(!it)
- break;
- multiallocation_iterator itend;
+ //Deallocate the rest of the blocks
- for(; it != itend; ++it){
- buffers.push_back(*it);
+ //Deallocate it in non sequential order
+ for(int j = 0, max = (int)buffers2.size()
+ ;j < max
+ ;++j){
+ int pos = (j%4)*((int)buffers2.size())/4;
+ a.deallocate(buffers2[pos]);
+ buffers2.erase(buffers2.begin()+pos);
}
- }
- for(int j = 0, max = (int)buffers.size()
- ;j < max
- ;++j){
- int pos = (j%4)*((int)buffers.size())/4;
- a.deallocate(buffers[pos]);
- buffers.erase(buffers.begin()+pos);
+ bool ok = free_memory == a.get_free_memory() &&
+ a.all_memory_deallocated() && a.check_sanity();
+ if(!ok) return ok;
}
-
- return a.all_memory_deallocated() && a.check_sanity();
+ return true;
}
//This function calls all tests
template<class Allocator>
bool test_all_allocation(Allocator &a)
{
- std::cout << "Starting test_allocation_direct_deallocation. Class: "
+ std::cout << "Starting test_allocation. Class: "
<< typeid(a).name() << std::endl;
- if(!test_allocation_direct_deallocation(a)){
+ if(!test_allocation(a)){
std::cout << "test_allocation_direct_deallocation failed. Class: "
<< typeid(a).name() << std::endl;
return false;
}
- std::cout << "Starting test_allocation_inverse_deallocation. Class: "
+ std::cout << "Starting test_many_equal_allocation. Class: "
<< typeid(a).name() << std::endl;
- if(!test_allocation_inverse_deallocation(a)){
- std::cout << "test_allocation_inverse_deallocation failed. Class: "
+ if(!test_many_equal_allocation(a)){
+ std::cout << "test_many_equal_allocation failed. Class: "
<< typeid(a).name() << std::endl;
return false;
}
- std::cout << "Starting test_allocation_mixed_deallocation. Class: "
+ std::cout << "Starting test_many_different_allocation. Class: "
<< typeid(a).name() << std::endl;
- if(!test_allocation_mixed_deallocation(a)){
- std::cout << "test_allocation_mixed_deallocation failed. Class: "
- << typeid(a).name() << std::endl;
- return false;
- }
-
- std::cout << "Starting test_many_equal_allocation_direct_deallocation. Class: "
- << typeid(a).name() << std::endl;
-
- if(!test_many_equal_allocation_direct_deallocation(a)){
- std::cout << "test_many_equal_allocation_direct_deallocation failed. Class: "
- << typeid(a).name() << std::endl;
- return false;
- }
-
- std::cout << "Starting test_many_equal_allocation_inverse_deallocation. Class: "
- << typeid(a).name() << std::endl;
-
- if(!test_many_equal_allocation_inverse_deallocation(a)){
- std::cout << "test_many_equal_allocation_inverse_deallocation failed. Class: "
- << typeid(a).name() << std::endl;
- return false;
- }
-
- std::cout << "Starting test_many_equal_allocation_mixed_deallocation. Class: "
- << typeid(a).name() << std::endl;
-
- if(!test_many_equal_allocation_mixed_deallocation(a)){
- std::cout << "test_many_equal_allocation_mixed_deallocation failed. Class: "
- << typeid(a).name() << std::endl;
- return false;
- }
-
- std::cout << "Starting test_many_different_allocation_direct_deallocation. Class: "
- << typeid(a).name() << std::endl;
-
- if(!test_many_different_allocation_direct_deallocation(a)){
- std::cout << "test_many_different_allocation_direct_deallocation failed. Class: "
- << typeid(a).name() << std::endl;
- return false;
- }
-
- std::cout << "Starting test_many_different_allocation_inverse_deallocation. Class: "
- << typeid(a).name() << std::endl;
-
- if(!test_many_different_allocation_inverse_deallocation(a)){
- std::cout << "test_many_different_allocation_inverse_deallocation failed. Class: "
- << typeid(a).name() << std::endl;
- return false;
- }
-
- std::cout << "Starting test_many_different_allocation_mixed_deallocation. Class: "
- << typeid(a).name() << std::endl;
-
- if(!test_many_different_allocation_mixed_deallocation(a)){
- std::cout << "test_many_different_allocation_mixed_deallocation failed. Class: "
+ if(!test_many_different_allocation(a)){
+ std::cout << "test_many_different_allocation failed. Class: "
<< typeid(a).name() << std::endl;
return false;
}
@@ -824,30 +766,45 @@
return false;
}
+ std::cout << "Starting test_allocation_deallocation_expand. Class: "
+ << typeid(a).name() << std::endl;
+
if(!test_allocation_deallocation_expand(a)){
std::cout << "test_allocation_deallocation_expand failed. Class: "
<< typeid(a).name() << std::endl;
return false;
}
+ std::cout << "Starting test_allocation_with_reuse. Class: "
+ << typeid(a).name() << std::endl;
+
if(!test_allocation_with_reuse(a)){
std::cout << "test_allocation_with_reuse failed. Class: "
<< typeid(a).name() << std::endl;
return false;
}
+ std::cout << "Starting test_aligned_allocation. Class: "
+ << typeid(a).name() << std::endl;
+
if(!test_aligned_allocation(a)){
std::cout << "test_aligned_allocation failed. Class: "
<< typeid(a).name() << std::endl;
return false;
}
+ std::cout << "Starting test_continuous_aligned_allocation. Class: "
+ << typeid(a).name() << std::endl;
+
if(!test_continuous_aligned_allocation(a)){
std::cout << "test_continuous_aligned_allocation failed. Class: "
<< typeid(a).name() << std::endl;
return false;
}
+ std::cout << "Starting test_clear_free_memory. Class: "
+ << typeid(a).name() << std::endl;
+
if(!test_clear_free_memory(a)){
std::cout << "test_clear_free_memory failed. Class: "
<< typeid(a).name() << std::endl;
Modified: trunk/libs/interprocess/test/node_pool_test.cpp
==============================================================================
--- trunk/libs/interprocess/test/node_pool_test.cpp (original)
+++ trunk/libs/interprocess/test/node_pool_test.cpp 2007-09-26 13:46:34 EDT (Wed, 26 Sep 2007)
@@ -7,7 +7,6 @@
// See http://www.boost.org/libs/interprocess for documentation.
//
//////////////////////////////////////////////////////////////////////////////
-/*
#include <boost/interprocess/detail/config_begin.hpp>
#include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/interprocess/allocators/detail/node_pool.hpp>
@@ -165,13 +164,3 @@
}
#include <boost/interprocess/detail/config_end.hpp>
-*/
-
-#include<stdlib.h>
-
-int main()
-{
- void *addr = malloc(100);
- free(addr);
- return 0;
-}
\ No newline at end of file
Modified: trunk/libs/interprocess/test/shared_ptr_test.cpp
==============================================================================
--- trunk/libs/interprocess/test/shared_ptr_test.cpp (original)
+++ trunk/libs/interprocess/test/shared_ptr_test.cpp 2007-09-26 13:46:34 EDT (Wed, 26 Sep 2007)
@@ -19,7 +19,6 @@
#include <boost/interprocess/allocators/allocator.hpp>
#include <boost/interprocess/containers/string.hpp>
#include <boost/interprocess/containers/vector.hpp>
-#include <boost/interprocess/detail/utilities.hpp>
#include <boost/interprocess/smart_ptr/deleter.hpp>
#include <boost/interprocess/smart_ptr/scoped_ptr.hpp>
#include <boost/detail/lightweight_test.hpp>
Modified: trunk/libs/interprocess/test/unique_ptr_test.cpp
==============================================================================
--- trunk/libs/interprocess/test/unique_ptr_test.cpp (original)
+++ trunk/libs/interprocess/test/unique_ptr_test.cpp 2007-09-26 13:46:34 EDT (Wed, 26 Sep 2007)
@@ -31,8 +31,7 @@
{}
};
-typedef deleter<MyClass, managed_shared_memory::segment_manager> my_deleter_type;
-typedef unique_ptr<MyClass, my_deleter_type> my_unique_ptr_class;
+typedef managed_unique_ptr<MyClass, managed_shared_memory>::type my_unique_ptr_class;
typedef set <my_unique_ptr_class
,std::less<my_unique_ptr_class>
,allocator <my_unique_ptr_class
@@ -58,19 +57,19 @@
shared_memory_object::remove(process_name.c_str());
{
managed_shared_memory segment(create_only, process_name.c_str(), 10000);
- my_deleter_type my_deleter(segment.get_segment_manager());
+
//Create unique_ptr using dynamic allocation
my_unique_ptr_class my_ptr (segment.construct<MyClass>(anonymous_instance)()
- ,my_deleter);
+ ,segment.get_deleter<MyClass>());
my_unique_ptr_class my_ptr2(segment.construct<MyClass>(anonymous_instance)()
- ,my_deleter);
+ ,segment.get_deleter<MyClass>());
//Backup relative pointers to future tests
offset_ptr<MyClass> ptr1 = my_ptr.get();
offset_ptr<MyClass> ptr2 = my_ptr2.get();
//Test some copy constructors
- my_unique_ptr_class my_ptr3(0, my_deleter);
+ my_unique_ptr_class my_ptr3(0, segment.get_deleter<MyClass>());
my_unique_ptr_class my_ptr4(move(my_ptr3));
//Construct a list and fill
@@ -141,7 +140,7 @@
assert(vector.begin()->get() == ptr1);
assert(vector.rbegin()->get() == ptr2);
- my_unique_ptr_class a(0, my_deleter), b(0, my_deleter);
+ my_unique_ptr_class a(0, segment.get_deleter<MyClass>()), b(0, segment.get_deleter<MyClass>());
a = move(b);
}
shared_memory_object::remove(process_name.c_str());