set_unit.C File Reference

Go to the source code of this file.

Functions
void	my_inserter (std::set< int > &s, int i)
void	my_inserter (std::multiset< int > &s, int i)
void	my_inserter (std::unordered_multiset< int > &s, int i)
void	my_inserter (std::set< std::vector< int >> &s, int i)
void	my_inserter (std::unordered_set< int > &s, int i)
void	my_inserter (std::map< int, int > &m, int i)
void	my_inserter (std::multimap< int, int > &m, int i)
void	my_inserter (std::unordered_multimap< int, int > &m, int i)
void	my_inserter (std::map< int, std::vector< int >> &m, int i)
void	my_inserter (std::unordered_map< int, int > &m, int i)
void	my_inserter (std::unordered_map< int, std::vector< int >> &m, int i)
void	tester (const std::set< int > &s, int i)
void	tester (const std::multiset< int > &s, int i)
void	tester (const std::unordered_multiset< int > &s, int i)
void	tester (const std::set< std::vector< int >> &s, int i)
void	tester (const std::unordered_set< int > &s, int i)
void	tester (const std::map< int, int > &m, int i)
void	tester (const std::multimap< int, int > &m, int i)
void	tester (const std::unordered_multimap< int, int > &m, int i)
void	tester (const std::map< int, std::vector< int >> &m, int i)
void	tester (const std::unordered_map< int, int > &m, int i)
void	tester (const std::unordered_map< int, std::vector< int >> &m, int i)
template<class Set >
void	testBigUnion (int n_multi=1)
template<class Set >
void	testUnion ()
void	testMapSet ()
void	testMapMap ()
int	main (int argc, const char *const *argv)

Variables
Communicator *	TestCommWorld

Function Documentation

main()

int main	(	int	argc,
		const char *const *	argv
	)

Definition at line 269 of file set_unit.C.

References TIMPI::TIMPIInit::comm(), TestCommWorld, testMapMap(), and testMapSet().

{
  TIMPI::TIMPIInit init(argc, argv);
  TestCommWorld = &init.comm();

  testBigUnion<std::set<int>>();
  testBigUnion<std::multiset<int>>(3);
  testBigUnion<std::unordered_multiset<int>>(3);
  testBigUnion<std::unordered_set<int>>();
  testBigUnion<std::map<int, int>>();
  testBigUnion<std::multimap<int, int>>(3);
  testBigUnion<std::unordered_multimap<int, int>>(3);
  testBigUnion<std::unordered_map<int, int>>();

  testUnion<std::set<int>>();
  testUnion<std::unordered_set<int>>();
  testUnion<std::map<int, int>>();
  testUnion<std::unordered_map<int, int>>();

  // TODO: allgather(vector<vector>)
  // testUnion<std::set<std::vector<int>>>();

  // No std::hash<vector<non-bool>>
  // testUnion<std::unordered_set<std::vector<int>>>();

  testUnion<std::map<int, std::vector<int>>>();
  testUnion<std::unordered_map<int, std::vector<int>>>();

  testMapSet();
  testMapMap();

  return 0;
}

my_inserter() [1/11]

void my_inserter	(	std::set< int > &	s,
		int	i
	)

Definition at line 17 of file set_unit.C.

Referenced by testBigUnion(), and testUnion().

{ s.insert(i); }

my_inserter() [2/11]

void my_inserter	(	std::multiset< int > &	s,
		int	i
	)

Definition at line 20 of file set_unit.C.

{
  s.insert(-1);
  s.insert(3*i+1);
  s.insert(3*i+2);
}

my_inserter() [3/11]

void my_inserter	(	std::unordered_multiset< int > &	s,
		int	i
	)

Definition at line 27 of file set_unit.C.

{
  s.insert(-1);
  s.insert(3*i+1);
  s.insert(3*i+2);
}

my_inserter() [4/11]

void my_inserter	(	std::set< std::vector< int >> &	s,
		int	i
	)

Definition at line 34 of file set_unit.C.

{ s.insert(std::vector<int>(i,i)); }

my_inserter() [5/11]

void my_inserter	(	std::unordered_set< int > &	s,
		int	i
	)

Definition at line 37 of file set_unit.C.

{ s.insert(i); }

my_inserter() [6/11]

void my_inserter	(	std::map< int, int > &	m,
		int	i
	)

Definition at line 40 of file set_unit.C.

{ m.insert(std::make_pair(i,2*i+3)); }

my_inserter() [7/11]

void my_inserter	(	std::multimap< int, int > &	m,
		int	i
	)

Definition at line 43 of file set_unit.C.

{
  m.insert(std::make_pair(-1,-1));
  m.insert(std::make_pair(i,3*i+1));
  m.insert(std::make_pair(i,3*i+2));
}

my_inserter() [8/11]

void my_inserter	(	std::unordered_multimap< int, int > &	m,
		int	i
	)

Definition at line 50 of file set_unit.C.

{
  m.insert(std::make_pair(-1,-1));
  m.insert(std::make_pair(i,3*i+1));
  m.insert(std::make_pair(i,3*i+2));
}

my_inserter() [9/11]

void my_inserter	(	std::map< int, std::vector< int >> &	m,
		int	i
	)

Definition at line 57 of file set_unit.C.

{ m.insert(std::make_pair(i,std::vector<int>(i,2*i+3))); }

my_inserter() [10/11]

void my_inserter	(	std::unordered_map< int, int > &	m,
		int	i
	)

Definition at line 60 of file set_unit.C.

{ m.insert(std::make_pair(i,2*i+3)); }

my_inserter() [11/11]

void my_inserter	(	std::unordered_map< int, std::vector< int >> &	m,
		int	i
	)

Definition at line 63 of file set_unit.C.

{ m.insert(std::make_pair(i,std::vector<int>(i,2*i+3))); }

testBigUnion()

template<class Set >

void testBigUnion

(

int

n_multi = 1

)

Definition at line 152 of file set_unit.C.

References my_inserter(), TIMPI::Communicator::rank(), TIMPI::Communicator::set_union(), TIMPI::Communicator::size(), TestCommWorld, and tester().

  {
    Set data;

    const int N = TestCommWorld->size();

    my_inserter(data, 150*N + TestCommWorld->rank());

    TestCommWorld->set_union(data);

    // The real assertions here are the internal ones in that
    // set_union
    TIMPI_UNIT_ASSERT( data.size() == n_multi * std::size_t(N) );
    for (int p=0; p<N; ++p)
      {
        tester(data, 150*N + p);
      }
  }

tester() [1/11]

void tester	(	const std::set< int > &	s,
		int	i
	)

Definition at line 67 of file set_unit.C.

Referenced by testBigUnion(), and testUnion().

{ TIMPI_UNIT_ASSERT( s.count(i) == std::size_t(1) ); }

tester() [2/11]

void tester	(	const std::multiset< int > &	s,
		int	i
	)

Definition at line 70 of file set_unit.C.

{
  TIMPI_UNIT_ASSERT( s.count(-1) * 3 == s.size() );
  TIMPI_UNIT_ASSERT( s.count(3*i+1) == std::size_t(1) );
  TIMPI_UNIT_ASSERT( s.count(3*i+2) == std::size_t(1) );
}

tester() [3/11]

void tester	(	const std::unordered_multiset< int > &	s,
		int	i
	)

Definition at line 77 of file set_unit.C.

{
  TIMPI_UNIT_ASSERT( s.count(-1) * 3 == s.size() );
  TIMPI_UNIT_ASSERT( s.count(3*i+1) == std::size_t(1) );
  TIMPI_UNIT_ASSERT( s.count(3*i+2) == std::size_t(1) );
}

tester() [4/11]

void tester	(	const std::set< std::vector< int >> &	s,
		int	i
	)

Definition at line 84 of file set_unit.C.

{ TIMPI_UNIT_ASSERT( s.count(std::vector<int>(i,i)) == std::size_t(1) ); }

tester() [5/11]

void tester	(	const std::unordered_set< int > &	s,
		int	i
	)

Definition at line 87 of file set_unit.C.

{ TIMPI_UNIT_ASSERT( s.count(i) == std::size_t(1) ); }

tester() [6/11]

void tester	(	const std::map< int, int > &	m,
		int	i
	)

Definition at line 90 of file set_unit.C.

{
  TIMPI_UNIT_ASSERT( m.count(i) == std::size_t(1) );
  TIMPI_UNIT_ASSERT( m.at(i) == 2*i+3 );
}

tester() [7/11]

void tester	(	const std::multimap< int, int > &	m,
		int	i
	)

Definition at line 96 of file set_unit.C.

{
  TIMPI_UNIT_ASSERT( m.count(-1) * 3 == m.size() );

  std::bitset<2> found;
  auto pr = m.equal_range(i);
  for (auto it = pr.first; it != pr.second; ++it)
    {
      auto val = it->second;
      TIMPI_UNIT_ASSERT( val > 3*i && val < 3*i+3 );
      TIMPI_UNIT_ASSERT( !found[val-3*i-1] );
      found[val-3*i-1] = true;
    }
  TIMPI_UNIT_ASSERT( found.count() == 2 );
}

tester() [8/11]

void tester	(	const std::unordered_multimap< int, int > &	m,
		int	i
	)

Definition at line 112 of file set_unit.C.

{
  TIMPI_UNIT_ASSERT( m.count(-1) * 3 == m.size() );

  std::bitset<2> found;
  const auto pr = m.equal_range(i);
  for (auto it = pr.first; it != pr.second; ++it)
    {
      auto val = it->second;
      TIMPI_UNIT_ASSERT( val > 3*i && val < 3*i+3 );
      TIMPI_UNIT_ASSERT( !found[val-3*i-1] );
      found[val-3*i-1] = true;
    }
  TIMPI_UNIT_ASSERT( found.count() == 2 );
}

tester() [9/11]

void tester	(	const std::map< int, std::vector< int >> &	m,
		int	i
	)

Definition at line 128 of file set_unit.C.

{
  TIMPI_UNIT_ASSERT( m.count(i) == std::size_t(1) );
  TIMPI_UNIT_ASSERT( m.at(i).size() == std::size_t(i) );
  for (auto val : m.at(i))
    TIMPI_UNIT_ASSERT( val == 2*i+3 );
}

tester() [10/11]

void tester	(	const std::unordered_map< int, int > &	m,
		int	i
	)

Definition at line 136 of file set_unit.C.

{
  TIMPI_UNIT_ASSERT( m.count(i) == std::size_t(1) );
  TIMPI_UNIT_ASSERT( m.at(i) == 2*i+3 );
}

tester() [11/11]

void tester	(	const std::unordered_map< int, std::vector< int >> &	m,
		int	i
	)

Definition at line 142 of file set_unit.C.

{
  TIMPI_UNIT_ASSERT( m.count(i) == std::size_t(1) );
  TIMPI_UNIT_ASSERT( m.at(i).size() == std::size_t(i) );
  for (auto val : m.at(i))
    TIMPI_UNIT_ASSERT( val == 2*i+3 );
}

testMapMap()

void testMapMap

(

)

Definition at line 236 of file set_unit.C.

References TIMPI::Communicator::rank(), TIMPI::Communicator::set_union(), and TestCommWorld.

Referenced by main().

  {
    std::map<unsigned int, std::map<unsigned short, double>> mapmap;

    // Values on all procs
    mapmap[0].emplace(20201, 0.8);

    // Insert extra values on procs 0 and 2
    switch (TestCommWorld->rank())
      {
      case 0:
      case 2:
        mapmap[0].emplace(60201, 1.);
        break;
      default:
        break;
      }

    TestCommWorld->set_union(mapmap);

    TIMPI_UNIT_ASSERT( mapmap.size() == 1 );
    const std::map<unsigned short, double> goodmap {{20201, 0.8},
                                                    {60201, 1}};
    for (const auto & pr : mapmap)
    {
      const auto & key = pr.first;
      const auto & boundary_id_map = pr.second;
      TIMPI_UNIT_ASSERT( key == 0 );
      TIMPI_UNIT_ASSERT( boundary_id_map == goodmap );
    }
  }

testMapSet()

void testMapSet

(

)

Definition at line 196 of file set_unit.C.

References TIMPI::Communicator::rank(), TIMPI::Communicator::set_union(), and TestCommWorld.

Referenced by main().

  {
    std::map<unsigned int, std::set<unsigned short>> mapset;

    // Values on all procs
    mapset[0].insert(20201);

    // Insert extra values on procs 0 and 2
    switch (TestCommWorld->rank())
      {
      case 0:
      case 2:
        mapset[0].insert(60201);
        break;
      default:
        break;
      }

    TestCommWorld->set_union(mapset);

    // Check results on all procs. In a broken 4-processor run what we
    // saw was:
    // key = 0, surface_ids = 20201 60201
    // key = 0, surface_ids = 20201
    // key = 0, surface_ids = 20201 60201
    // key = 0, surface_ids = 20201
    // whereas what we expect to see is that all procs have the
    // same surface_ids, the ones from pid 0.
    TIMPI_UNIT_ASSERT( mapset.size() == 1 );
    const std::set<unsigned short> goodset {20201, 60201};
    for (const auto & pr : mapset)
    {
      const auto & key = pr.first;
      const auto & boundary_id_set = pr.second;
      TIMPI_UNIT_ASSERT( key == 0 );
      TIMPI_UNIT_ASSERT( boundary_id_set == goodset );
    }
  }

testUnion()

template<class Set >

void testUnion

(

)

Definition at line 174 of file set_unit.C.

References my_inserter(), TIMPI::Communicator::rank(), TIMPI::Communicator::set_union(), TIMPI::Communicator::size(), TestCommWorld, and tester().

  {
    Set data;

    const int N = TestCommWorld->size();

    my_inserter(data, TestCommWorld->rank());
    my_inserter(data, 2*N);
    my_inserter(data, 3*N + TestCommWorld->rank());

    TestCommWorld->set_union(data);

    TIMPI_UNIT_ASSERT( data.size() == std::size_t(2*N+1) );
    tester(data, 2*N);
    for (int p=0; p<N; ++p)
      {
        tester(data, p);
        tester(data, 3*N+p);
      }
  }

Variable Documentation

TestCommWorld

Communicator* TestCommWorld

Definition at line 15 of file set_unit.C.

Referenced by main(), testBigUnion(), testMapMap(), testMapSet(), and testUnion().