F14InterprocessTest.cpp File Reference

#include <ios>
#include <iostream>
#include <memory>
#include <scoped_allocator>
#include <string>
#include <vector>
#include <boost/interprocess/allocators/adaptive_pool.hpp>
#include <boost/interprocess/managed_shared_memory.hpp>
#include <folly/Format.h>
#include <folly/Random.h>
#include <folly/Traits.h>
#include <folly/container/F14Map.h>
#include <folly/container/F14Set.h>
#include <folly/container/test/F14TestUtil.h>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Typedefs
template<typename T >
using	ShmAllocator = adaptive_pool< T, managed_shared_memory::segment_manager >
template<typename K , typename M >
using	ShmF14ValueMap = folly::F14ValueMap< K, M, folly::f14::DefaultHasher< K >, folly::f14::DefaultKeyEqual< K >, ShmAllocator< std::pair< K const, M >>>
template<typename K , typename M >
using	ShmF14NodeMap = folly::F14NodeMap< K, M, folly::f14::DefaultHasher< K >, folly::f14::DefaultKeyEqual< K >, ShmAllocator< std::pair< K const, M >>>
template<typename K , typename M >
using	ShmF14VectorMap = folly::F14VectorMap< K, M, folly::f14::DefaultHasher< K >, folly::f14::DefaultKeyEqual< K >, ShmAllocator< std::pair< K const, M >>>
template<typename K >
using	ShmF14ValueSet = folly::F14ValueSet< K, folly::f14::DefaultHasher< K >, folly::f14::DefaultKeyEqual< K >, ShmAllocator< K >>
template<typename K >
using	ShmF14NodeSet = folly::F14NodeSet< K, folly::f14::DefaultHasher< K >, folly::f14::DefaultKeyEqual< K >, ShmAllocator< K >>
template<typename K >
using	ShmF14VectorSet = folly::F14VectorSet< K, folly::f14::DefaultHasher< K >, folly::f14::DefaultKeyEqual< K >, ShmAllocator< K >>
using	ShmVI = std::vector< int, ShmAllocator< int >>
using	ShmVVI = std::vector< ShmVI, std::scoped_allocator_adaptor< ShmAllocator< ShmVI >>>
using	ShmF14ValueI2VVI = folly::F14ValueMap< int, ShmVVI, folly::f14::DefaultHasher< int >, folly::f14::DefaultKeyEqual< int >, std::scoped_allocator_adaptor< ShmAllocator< std::pair< int const, ShmVVI >>>>
using	ShmF14NodeI2VVI = folly::F14NodeMap< int, ShmVVI, folly::f14::DefaultHasher< int >, folly::f14::DefaultKeyEqual< int >, std::scoped_allocator_adaptor< ShmAllocator< std::pair< int const, ShmVVI >>>>
using	ShmF14VectorI2VVI = folly::F14VectorMap< int, ShmVVI, folly::f14::DefaultHasher< int >, folly::f14::DefaultKeyEqual< int >, std::scoped_allocator_adaptor< ShmAllocator< std::pair< int const, ShmVVI >>>>

Functions
template<typename M >
void	runSimpleMapTest ()
template<typename S >
void	runSimpleSetTest ()
	TEST (ShmF14ValueMap, simple)
	TEST (ShmF14NodeMap, simple)
	TEST (ShmF14VectorMap, simple)
	TEST (ShmF14ValueSet, simple)
	TEST (ShmF14NodeSet, simple)
	TEST (ShmF14VectorSet, simple)
template<typename M >
void	runSimultaneousAccessMapTest ()
	TEST (ShmF14ValueMap, simultaneous)
	TEST (ShmF14NodeMap, simultaneous)
	TEST (ShmF14VectorMap, simultaneous)
template<typename T >
void	checkSingleLocation (std::string name, std::shared_ptr< managed_shared_memory > const &segment, T const &val)
void	checkLocation (std::string name, std::shared_ptr< managed_shared_memory > const &segment, int const &val)
template<typename A , typename B >
void	checkLocation (std::string name, std::shared_ptr< managed_shared_memory > const &segment, std::pair< A, B > const &val)
template<typename T >
auto	checkLocation (std::string name, std::shared_ptr< managed_shared_memory > const &segment, T const &val) -> folly::void_t< decltype(val.begin())>
template<typename M >
void	runScopedAllocatorTest ()
	TEST (ShmF14ValueI2VVI, scopedAllocator)
	TEST (ShmF14NodeI2VVI, scopedAllocator)
	TEST (ShmF14VectorI2VVI, scopedAllocator)
template<typename M >
void	runMultiScopeTest ()
	TEST (ShmF14ValueI2VVI, multiScope)
	TEST (ShmF14NodeI2VVI, multiScope)
	TEST (ShmF14VectorI2VVI, multiScope)

Typedef Documentation

template<typename T >

using ShmAllocator = adaptive_pool<T, managed_shared_memory::segment_manager>

Definition at line 38 of file F14InterprocessTest.cpp.

using ShmF14NodeI2VVI = folly::F14NodeMap< int, ShmVVI, folly::f14::DefaultHasher<int>, folly::f14::DefaultKeyEqual<int>, std::scoped_allocator_adaptor<ShmAllocator<std::pair<int const, ShmVVI>>>>

Definition at line 101 of file F14InterprocessTest.cpp.

template<typename K , typename M >

using ShmF14NodeMap = folly::F14NodeMap< K, M, folly::f14::DefaultHasher<K>, folly::f14::DefaultKeyEqual<K>, ShmAllocator<std::pair<K const, M>>>

Definition at line 54 of file F14InterprocessTest.cpp.

template<typename K >

using ShmF14NodeSet = folly::F14NodeSet< K, folly::f14::DefaultHasher<K>, folly::f14::DefaultKeyEqual<K>, ShmAllocator<K>>

Definition at line 76 of file F14InterprocessTest.cpp.

using ShmF14ValueI2VVI = folly::F14ValueMap< int, ShmVVI, folly::f14::DefaultHasher<int>, folly::f14::DefaultKeyEqual<int>, std::scoped_allocator_adaptor<ShmAllocator<std::pair<int const, ShmVVI>>>>

Definition at line 94 of file F14InterprocessTest.cpp.

template<typename K , typename M >

using ShmF14ValueMap = folly::F14ValueMap< K, M, folly::f14::DefaultHasher<K>, folly::f14::DefaultKeyEqual<K>, ShmAllocator<std::pair<K const, M>>>

Definition at line 46 of file F14InterprocessTest.cpp.

template<typename K >

using ShmF14ValueSet = folly::F14ValueSet< K, folly::f14::DefaultHasher<K>, folly::f14::DefaultKeyEqual<K>, ShmAllocator<K>>

Definition at line 69 of file F14InterprocessTest.cpp.

using ShmF14VectorI2VVI = folly::F14VectorMap< int, ShmVVI, folly::f14::DefaultHasher<int>, folly::f14::DefaultKeyEqual<int>, std::scoped_allocator_adaptor<ShmAllocator<std::pair<int const, ShmVVI>>>>

Definition at line 108 of file F14InterprocessTest.cpp.

template<typename K , typename M >

using ShmF14VectorMap = folly::F14VectorMap< K, M, folly::f14::DefaultHasher<K>, folly::f14::DefaultKeyEqual<K>, ShmAllocator<std::pair<K const, M>>>

Definition at line 62 of file F14InterprocessTest.cpp.

template<typename K >

using ShmF14VectorSet = folly::F14VectorSet< K, folly::f14::DefaultHasher<K>, folly::f14::DefaultKeyEqual<K>, ShmAllocator<K>>

Definition at line 83 of file F14InterprocessTest.cpp.

using ShmVI = std::vector<int, ShmAllocator<int>>

Definition at line 85 of file F14InterprocessTest.cpp.

using ShmVVI = std::vector<ShmVI, std::scoped_allocator_adaptor<ShmAllocator<ShmVI>>>

Definition at line 87 of file F14InterprocessTest.cpp.

Function Documentation

void checkLocation	(	std::string	name,
		std::shared_ptr< managed_shared_memory > const &	segment,
		int const &	val
	)

Definition at line 249 of file F14InterprocessTest.cpp.

References checkSingleLocation().

Referenced by checkLocation(), checkSingleLocation(), runMultiScopeTest(), and runScopedAllocatorTest().

                    {
  checkSingleLocation(name, segment, val);
}

template<typename A , typename B >

void checkLocation	(	std::string	name,
		std::shared_ptr< managed_shared_memory > const &	segment,
		std::pair< A, B > const &	val
	)

Definition at line 257 of file F14InterprocessTest.cpp.

References checkLocation(), and checkSingleLocation().

                              {
  checkSingleLocation(name, segment, val);
  checkLocation(name + ".first", segment, val.first);
  checkLocation(name + ".second", segment, val.second);
}

template<typename T >

auto checkLocation	(	std::string	name,
		std::shared_ptr< managed_shared_memory > const &	segment,
		T const &	val
	)		-> folly::void_t<decltype(val.begin())>

Definition at line 267 of file F14InterprocessTest.cpp.

References checkLocation(), checkSingleLocation(), EXPECT_TRUE, name, and val.

                                                        {
  typename T::allocator_type alloc{segment->get_segment_manager()};
  EXPECT_TRUE(alloc == val.get_allocator());
  checkSingleLocation(name, segment, val);
  for (auto&& v : val) {
    checkLocation(name + "[]", segment, v);
  }
}

template<typename T >

void checkSingleLocation	(	std::string	name,
		std::shared_ptr< managed_shared_memory > const &	segment,
		T const &	val
	)

Definition at line 219 of file F14InterprocessTest.cpp.

References addr, checkLocation(), EXPECT_TRUE, name, string, T, and val.

Referenced by checkLocation().

                  {
  auto beginAddr = reinterpret_cast<uintptr_t>(segment->get_address());
  auto endAddr = beginAddr + segment->get_size();
  auto addr = reinterpret_cast<uintptr_t>(&val);
  EXPECT_TRUE(beginAddr <= addr && addr + sizeof(T) <= endAddr)
      << name << ": begin @" << std::hex << beginAddr << ", val @" << std::hex
      << addr << ", size" << std::hex << sizeof(T) << ", end @" << std::hex
      << endAddr;
}

template<typename M >

void runMultiScopeTest

(

)

Definition at line 315 of file F14InterprocessTest.cpp.

References checkLocation(), EXPECT_EQ, EXPECT_FALSE, EXPECT_TRUE, folly::gen::move, and folly::f14::swap().

                         {
  auto segment1 = makeShmSegment(8192);
  auto mgr1 = segment1->get_segment_manager();

  auto segment2 = makeShmSegment(8192);
  auto mgr2 = segment2->get_segment_manager();

  auto a1 = segment1->construct<M>(anonymous_instance)(
      typename M::allocator_type{mgr1});
  (*a1)[1].emplace_back();
  (*a1)[1][0].push_back(3);
  auto b1 = segment1->construct<M>(anonymous_instance)(*a1);
  auto c1 = segment1->construct<M>(anonymous_instance)(std::move(*a1));

  auto d2 = segment2->construct<M>(anonymous_instance)(
      typename M::allocator_type{mgr2});
  (*d2)[10].emplace_back();
  (*d2)[10][0].push_back(6);
  auto e2 = segment2->construct<M>(anonymous_instance)(*d2);
  auto f2 = segment2->construct<M>(anonymous_instance)(
      *b1, typename M::allocator_type{mgr2});

  checkLocation("a1", segment1, *a1);
  checkLocation("b1", segment1, *b1);
  checkLocation("c1", segment1, *c1);
  checkLocation("d2", segment2, *d2);
  checkLocation("e2", segment2, *e2);
  checkLocation("f2", segment2, *f2);

  EXPECT_EQ(a1->size(), 0);
  EXPECT_FALSE(*a1 == *b1);
  EXPECT_TRUE(*b1 == *c1);
  EXPECT_TRUE(*b1 == *f2);
  EXPECT_EQ(d2->size(), 1);
  EXPECT_EQ(e2->size(), 1);
  EXPECT_FALSE(*e2 == *f2);

  checkLocation("d2", segment2, *d2);

  EXPECT_TRUE(*d2 == *e2);

  f2->clear();
  *f2 = std::move(*d2);

  checkLocation("d2", segment2, *d2);
  checkLocation("f2", segment2, *f2);

  EXPECT_TRUE(*f2 == *e2);
  EXPECT_TRUE(d2->empty());

  {
    using std::swap;
    swap(*a1, *b1);
  }
  checkLocation("a1", segment1, *a1);
  checkLocation("b1", segment1, *b1);
  EXPECT_TRUE(*a1 == *c1);

  *a1 = std::move(*e2);

  EXPECT_TRUE(*f2 == *a1);

  checkLocation("a1", segment1, *a1);
  checkLocation("e2", segment2, *e2);

  auto g2 = segment2->construct<M>(anonymous_instance)(
      std::move(*a1), typename M::allocator_type{mgr2});

  EXPECT_TRUE(*f2 == *g2);

  checkLocation("f2", segment2, *f2);
  checkLocation("g2", segment2, *g2);

  segment1->destroy_ptr(a1);
  segment1->destroy_ptr(b1);
  segment1->destroy_ptr(c1);
  segment2->destroy_ptr(d2);
  segment2->destroy_ptr(e2);
  segment2->destroy_ptr(f2);
  segment2->destroy_ptr(g2);
}

template<typename M >

void runScopedAllocatorTest

(

)

Definition at line 280 of file F14InterprocessTest.cpp.

References checkLocation(), and m.

                              {
  auto segment = makeShmSegment(8192);
  auto mgr = segment->get_segment_manager();

  auto vi = segment->construct<ShmVI>(anonymous_instance)(
      typename ShmVI::allocator_type{mgr});
  vi->push_back(10);
  checkLocation("vi", segment, *vi);

  auto vvi = segment->construct<ShmVVI>(anonymous_instance)(
      typename ShmVVI::allocator_type{mgr});
  vvi->resize(1);
  vvi->at(0).push_back(2);
  checkLocation("vvi", segment, *vvi);

  auto m = segment->construct<M>(anonymous_instance)(
      typename M::allocator_type{mgr});
  (*m)[1].emplace_back();
  (*m)[1][0].push_back(3);

  checkLocation("m", segment, *m);
  m->clear();
}

template<typename M >

void runSimpleMapTest

(

)

Definition at line 129 of file F14InterprocessTest.cpp.

References EXPECT_EQ, i, and m.

                        {
  auto segment = makeShmSegment(8192);
  auto mgr = segment->get_segment_manager();
  ShmAllocator<std::pair<int const, int>> alloc{mgr};
  M m{alloc};
  for (int i = 0; i < 20; ++i) {
    m[i] = i * 10;
  }
  EXPECT_EQ(m.size(), 20);
  for (int i = 0; i < 20; ++i) {
    EXPECT_EQ(m[i], i * 10);
  }
}

template<typename S >

void runSimpleSetTest

(

)

Definition at line 144 of file F14InterprocessTest.cpp.

References EXPECT_EQ, i, and s.

                        {
  auto segment = makeShmSegment(8192);
  auto mgr = segment->get_segment_manager();
  S s{typename S::allocator_type{mgr}};
  for (int i = 0; i < 20; ++i) {
    s.insert(i);
  }
  EXPECT_EQ(s.size(), 20);
  for (int i = 0; i < 40; ++i) {
    EXPECT_EQ(s.count(i), (i < 20 ? 1 : 0));
  }
}

template<typename M >

void runSimultaneousAccessMapTest

(

)

Definition at line 177 of file F14InterprocessTest.cpp.

References EXPECT_EQ, EXPECT_FALSE, EXPECT_NE, folly::gen::first, folly::f14::detail::getF14IntrinsicsMode(), and name.

                                    {
  using namespace folly::f14::detail;

  // fallback std::unordered_map on libstdc++ doesn't pass this test
  if (getF14IntrinsicsMode() != F14IntrinsicsMode::None) {
    auto name = makeRandomName();
    auto segment1 = makeShmSegment(8192, name);
    auto segment2 =
        std::make_shared<managed_shared_memory>(open_only, name.c_str());

    auto m1 = segment1->construct<M>("m")(
        typename M::allocator_type{segment1->get_segment_manager()});
    auto m2 = segment2->find<M>("m").first;

    std::cout << "m in segment1 @ " << (uintptr_t)m1 << "\n";
    std::cout << "m in segment2 @ " << (uintptr_t)m2 << "\n";

    EXPECT_NE(&*m1, &*m2);

    (*m1)[1] = 10;
    EXPECT_EQ(m2->count(0), 0);
    EXPECT_EQ((*m2)[1], 10);
    (*m2)[2] = 20;
    EXPECT_EQ(m1->size(), 2);
    EXPECT_EQ(m1->find(2)->second, 20);
    (*m1)[3] = 30;
    EXPECT_EQ(m2->size(), 3);
    EXPECT_FALSE(m2->emplace(std::make_pair(3, 33)).second);
  }
}

TEST	(	ShmF14ValueMap	,
		simple
	)

Definition at line 157 of file F14InterprocessTest.cpp.

                             {
  runSimpleMapTest<ShmF14ValueMap<int, int>>();
}

TEST	(	ShmF14NodeMap	,
		simple
	)

Definition at line 160 of file F14InterprocessTest.cpp.

                            {
  runSimpleMapTest<ShmF14NodeMap<int, int>>();
}

TEST	(	ShmF14VectorMap	,
		simple
	)

Definition at line 163 of file F14InterprocessTest.cpp.

                              {
  runSimpleMapTest<ShmF14VectorMap<int, int>>();
}

TEST	(	ShmF14ValueSet	,
		simple
	)

Definition at line 166 of file F14InterprocessTest.cpp.

                             {
  runSimpleSetTest<ShmF14ValueSet<int>>();
}

TEST	(	ShmF14NodeSet	,
		simple
	)

Definition at line 169 of file F14InterprocessTest.cpp.

                            {
  runSimpleSetTest<ShmF14NodeSet<int>>();
}

TEST	(	ShmF14VectorSet	,
		simple
	)

Definition at line 172 of file F14InterprocessTest.cpp.

                              {
  runSimpleSetTest<ShmF14VectorSet<int>>();
}

TEST	(	ShmF14ValueMap	,
		simultaneous
	)

Definition at line 208 of file F14InterprocessTest.cpp.

                                   {
  runSimultaneousAccessMapTest<ShmF14ValueMap<int, int>>();
}

TEST	(	ShmF14NodeMap	,
		simultaneous
	)

Definition at line 211 of file F14InterprocessTest.cpp.

                                  {
  runSimultaneousAccessMapTest<ShmF14NodeMap<int, int>>();
}

TEST	(	ShmF14VectorMap	,
		simultaneous
	)

Definition at line 214 of file F14InterprocessTest.cpp.

                                    {
  runSimultaneousAccessMapTest<ShmF14VectorMap<int, int>>();
}

TEST	(	ShmF14ValueI2VVI	,
		scopedAllocator
	)

Definition at line 304 of file F14InterprocessTest.cpp.

                                        {
  runScopedAllocatorTest<ShmF14ValueI2VVI>();
}

TEST	(	ShmF14NodeI2VVI	,
		scopedAllocator
	)

Definition at line 307 of file F14InterprocessTest.cpp.

                                       {
  runScopedAllocatorTest<ShmF14NodeI2VVI>();
}

TEST	(	ShmF14VectorI2VVI	,
		scopedAllocator
	)

Definition at line 310 of file F14InterprocessTest.cpp.

                                         {
  runScopedAllocatorTest<ShmF14VectorI2VVI>();
}

TEST	(	ShmF14ValueI2VVI	,
		multiScope
	)

Definition at line 397 of file F14InterprocessTest.cpp.

                                   {
  runMultiScopeTest<ShmF14ValueI2VVI>();
}

TEST	(	ShmF14NodeI2VVI	,
		multiScope
	)

Definition at line 400 of file F14InterprocessTest.cpp.

                                  {
  runMultiScopeTest<ShmF14NodeI2VVI>();
}

TEST	(	ShmF14VectorI2VVI	,
		multiScope
	)

Definition at line 403 of file F14InterprocessTest.cpp.

                                    {
  runMultiScopeTest<ShmF14VectorI2VVI>();
}