UninitializedMemoryHacksTest.cpp File Reference

#include <folly/memory/UninitializedMemoryHacks.h>
#include <algorithm>
#include <string>
#include <vector>
#include <folly/Memory.h>
#include <folly/Random.h>
#include <folly/portability/GTest.h>
#include <glog/logging.h>

Go to the source code of this file.

Functions
void	describePlatform ()
template<typename T >
T	validData (T const &target, std::vector< bool > const &valid)
template<typename T >
void	doResizeWithoutInit (T &target, std::vector< bool > &valid, std::size_t newSize)
template<typename T >
void	doOverwrite (T &target, std::vector< bool > &valid, std::size_t b, std::size_t e)
template<typename T >
void	doResize (T &target, std::vector< bool > &valid, std::size_t newSize)
template<typename T >
void	doClear (T &target, std::vector< bool > &valid)
template<typename T >
void	doInsert (T &target, std::vector< bool > &valid, std::size_t i)
template<typename T >
void	doErase (T &target, std::vector< bool > &valid, std::size_t i)
template<typename T >
void	doPushBack (T &target, std::vector< bool > &valid)
template<typename T >
void	genericCheck (T &target)
template<typename T >
void	check (T &target)
template<>
void	check< std::string > (std::string &target)
template<typename T >
void	testSimple ()
template<typename T >
void	testRandom (size_t numSteps=10000)
	TEST (UninitializedMemoryHacks, simpleString)
	TEST (UninitializedMemoryHacks, simpleVectorChar)
	TEST (UninitializedMemoryHacks, simpleVectorByte)
	TEST (UninitializedMemoryHacks, simpleVectorInt)
	TEST (UninitializedMemoryHacks, randomString)
	TEST (UninitializedMemoryHacks, randomVectorChar)
	TEST (UninitializedMemoryHacks, randomVectorByte)
	TEST (UninitializedMemoryHacks, randomVectorInt)

Function Documentation

template<typename T >

void check

(

T &

target

)

Definition at line 164 of file UninitializedMemoryHacksTest.cpp.

References genericCheck().

Referenced by testRandom(), and testSimple().

                      {
  genericCheck(target);
}

template<>

void check< std::string >

(

std::string &

target

)

Definition at line 169 of file UninitializedMemoryHacksTest.cpp.

References EXPECT_EQ, and genericCheck().

                                         {
  genericCheck(target);
  EXPECT_EQ(target.c_str(), target.data());
  EXPECT_EQ(target.c_str()[target.size()], '\0');
}

void describePlatform

(

)

Definition at line 28 of file UninitializedMemoryHacksTest.cpp.

References string.

Referenced by testRandom(), and testSimple().

                        {
  LOG(INFO) << "sizeof(void*) = " << sizeof(void*);

  LOG(INFO) << "sizeof(std::string) = " << sizeof(std::string);
#if defined(_LIBCPP_STRING)
  LOG(INFO) << "std::string from libc++";
#elif defined(_STLP_STRING)
  LOG(INFO) << "std::string from STLport";
#elif defined(_GLIBCXX_USE_FB)
  LOG(INFO) << "std::string from FBString";
#elif defined(_GLIBCXX_STRING) && _GLIBCXX_USE_CXX11_ABI
  LOG(INFO) << "std::string from libstdc++ with SSO";
#elif defined(_GLIBCXX_STRING)
  LOG(INFO) << "std::string from old libstdc++";
#elif defined(_MSC_VER)
  LOG(INFO) << "std::string from MSVC";
#else
  LOG(INFO) << "UNKNOWN std::string implementation";
#endif

  LOG(INFO) << "sizeof(std::vector<char>) = " << sizeof(std::vector<char>);
#if defined(_LIBCPP_VECTOR)
  LOG(INFO) << "std::vector from libc++";
#elif defined(_STLP_VECTOR)
  LOG(INFO) << "std::vector from STLport";
#elif defined(_GLIBCXX_VECTOR)
  LOG(INFO) << "std::vector from libstdc++";
#elif defined(_MSC_VER)
  LOG(INFO) << "std::vector from MSVC";
#else
  LOG(INFO) << "UNKNOWN std::vector implementation";
#endif
}

template<typename T >

void doClear	(	T &	target,
		std::vector< bool > &	valid
	)

Definition at line 127 of file UninitializedMemoryHacksTest.cpp.

Referenced by testRandom().

                                                {
  target.clear();
  valid.clear();
}

template<typename T >

void doErase	(	T &	target,
		std::vector< bool > &	valid,
		std::size_t	i
	)

Definition at line 139 of file UninitializedMemoryHacksTest.cpp.

References i.

Referenced by testRandom().

                                                             {
  target.erase(target.begin() + i);
  valid.erase(valid.begin() + i);
}

template<typename T >

void doInsert	(	T &	target,
		std::vector< bool > &	valid,
		std::size_t	i
	)

Definition at line 133 of file UninitializedMemoryHacksTest.cpp.

References i.

Referenced by testRandom().

                                                              {
  target.insert(target.begin() + i, 'I');
  valid.insert(valid.begin() + i, true);
}

template<typename T >

void doOverwrite	(	T &	target,
		std::vector< bool > &	valid,
		std::size_t	b,
		std::size_t	e
	)

Definition at line 94 of file UninitializedMemoryHacksTest.cpp.

References i.

Referenced by testRandom(), and testSimple().

                 {
  for (auto i = b; i < e && i < target.size(); ++i) {
    target[i] = '0' + (i % 10);
    valid[i] = true;
  }
}

template<typename T >

void doPushBack	(	T &	target,
		std::vector< bool > &	valid
	)

Definition at line 145 of file UninitializedMemoryHacksTest.cpp.

Referenced by testRandom().

                                                   {
  target.push_back('P');
  valid.push_back(true);
}

template<typename T >

void doResize	(	T &	target,
		std::vector< bool > &	valid,
		std::size_t	newSize
	)

Definition at line 106 of file UninitializedMemoryHacksTest.cpp.

References EXPECT_EQ, EXPECT_GE, EXPECT_LT, EXPECT_TRUE, i, and validData().

Referenced by testRandom(), and testSimple().

                                                                    {
  auto oldSize = target.size();
  auto before = validData(target, valid);
  target.resize(newSize);
  valid.resize(newSize);
  for (auto i = oldSize; i < newSize; ++i) {
    valid[i] = true;
  }
  auto after = validData(target, valid);
  if (oldSize == newSize) {
    EXPECT_EQ(before, after);
  } else if (oldSize < newSize) {
    EXPECT_LT(before.size(), after.size());
    EXPECT_TRUE(std::equal(before.begin(), before.end(), after.begin()));
  } else {
    EXPECT_GE(before.size(), after.size());
    EXPECT_TRUE(std::equal(after.begin(), after.end(), before.begin()));
  }
}

template<typename T >

void doResizeWithoutInit	(	T &	target,
		std::vector< bool > &	valid,
		std::size_t	newSize
	)

Definition at line 76 of file UninitializedMemoryHacksTest.cpp.

References EXPECT_EQ, EXPECT_GE, EXPECT_TRUE, folly::resizeWithoutInitialization(), and validData().

Referenced by testRandom(), and testSimple().

                       {
  auto oldSize = target.size();
  auto before = validData(target, valid);
  folly::resizeWithoutInitialization(target, newSize);
  valid.resize(newSize);
  auto after = validData(target, valid);
  if (oldSize <= newSize) {
    EXPECT_EQ(before, after);
  } else {
    EXPECT_GE(before.size(), after.size());
    EXPECT_TRUE(std::equal(after.begin(), after.end(), before.begin()));
  }
}

template<typename T >

void genericCheck

(

T &

target

)

Definition at line 151 of file UninitializedMemoryHacksTest.cpp.

References EXPECT_EQ, and EXPECT_LE.

Referenced by check(), and check< std::string >().

                             {
  EXPECT_LE(target.size(), target.capacity());
  EXPECT_EQ(target.size() == 0, target.empty());
  EXPECT_EQ(target.size(), target.end() - target.begin());
  EXPECT_EQ(target.size(), target.cend() - target.cbegin());
  if (!target.empty()) {
    EXPECT_EQ(target.data(), &target[0]);
    EXPECT_EQ(target.data(), &target.front());
    EXPECT_EQ(target.data() + target.size() - 1, &target.back());
  }
}

TEST	(	UninitializedMemoryHacks	,
		simpleString
	)

Definition at line 283 of file UninitializedMemoryHacksTest.cpp.

                                             {
  testSimple<std::string>();
}

TEST	(	UninitializedMemoryHacks	,
		simpleVectorChar
	)

Definition at line 287 of file UninitializedMemoryHacksTest.cpp.

                                                 {
  testSimple<std::vector<char>>();
}

TEST	(	UninitializedMemoryHacks	,
		simpleVectorByte
	)

Definition at line 291 of file UninitializedMemoryHacksTest.cpp.

                                                 {
  testSimple<std::vector<uint8_t>>();
}

TEST	(	UninitializedMemoryHacks	,
		simpleVectorInt
	)

Definition at line 295 of file UninitializedMemoryHacksTest.cpp.

                                                {
  testSimple<std::vector<int>>();
}

TEST	(	UninitializedMemoryHacks	,
		randomString
	)

Definition at line 299 of file UninitializedMemoryHacksTest.cpp.

                                             {
  testRandom<std::string>();
}

TEST	(	UninitializedMemoryHacks	,
		randomVectorChar
	)

Definition at line 303 of file UninitializedMemoryHacksTest.cpp.

                                                 {
  testRandom<std::vector<char>>();
}

TEST	(	UninitializedMemoryHacks	,
		randomVectorByte
	)

Definition at line 307 of file UninitializedMemoryHacksTest.cpp.

                                                 {
  testRandom<std::vector<uint8_t>>();
}

TEST	(	UninitializedMemoryHacks	,
		randomVectorInt
	)

Definition at line 311 of file UninitializedMemoryHacksTest.cpp.

                                                {
  testRandom<std::vector<int>>();
}

template<typename T >

void testRandom

(

size_t

numSteps = 10000

)

Definition at line 221 of file UninitializedMemoryHacksTest.cpp.

References check(), folly::copy(), describePlatform(), doClear(), doErase(), doInsert(), doOverwrite(), doPushBack(), doResize(), doResizeWithoutInit(), i, max, min, folly::gen::move, folly::Random::rand32(), folly::resizeWithoutInitialization(), folly::f14::swap(), T, and uint32_t.

                                         {
  describePlatform();

  auto target = folly::make_unique<T>();
  std::vector<bool> valid;

  for (size_t step = 0; step < numSteps; ++step) {
    auto pct = folly::Random::rand32(100);
    auto v = folly::Random::rand32(uint32_t{3} << folly::Random::rand32(14));

    if (pct < 5) {
      doClear(*target, valid);
    } else if (pct < 30) {
      T copy;
      folly::resizeWithoutInitialization(copy, target->size());
      for (size_t i = 0; i < copy.size(); ++i) {
        if (valid[i]) {
          copy[i] = target->at(i);
        }
      }
      if (pct < 10) {
        std::swap(copy, *target);
      } else if (pct < 15) {
        *target = std::move(copy);
      } else if (pct < 20) {
        *target = copy;
      } else if (pct < 25) {
        target = folly::make_unique<T>(std::move(copy));
      } else {
        target = folly::make_unique<T>(copy);
      }
    } else if (pct < 35) {
      target->reserve(v);
    } else if (pct < 40) {
      target->shrink_to_fit();
    } else if (pct < 45) {
      doResize(*target, valid, v);
    } else if (pct < 50) {
      doInsert(*target, valid, v % (target->size() + 1));
    } else if (pct < 55) {
      if (!target->empty()) {
        doErase(*target, valid, v % target->size());
      }
    } else if (pct < 60) {
      doPushBack(*target, valid);
    } else if (pct < 65) {
      target = folly::make_unique<T>();
      valid.clear();
    } else if (pct < 80) {
      auto v2 = folly::Random::rand32(uint32_t{3} << folly::Random::rand32(14));
      doOverwrite(*target, valid, std::min(v, v2), std::max(v, v2));
    } else {
      doResizeWithoutInit(*target, valid, v);
    }

    // don't check every time in implementation does lazy work
    if (folly::Random::rand32(100) < 50) {
      check(*target);
    }
  }
}

template<typename T >

void testSimple

(

)

Definition at line 176 of file UninitializedMemoryHacksTest.cpp.

References check(), describePlatform(), doOverwrite(), doResize(), doResizeWithoutInit(), i, sizes, and T.

Referenced by proxygen::RFC1867Base::parse(), proxygen::TEST_F(), and proxygen::TEST_P().

                  {
  describePlatform();

  auto sizes = {0, 1, 10, 14, 15, 16, 17, 22, 23, 24, 32, 95, 100, 10000};
  for (auto i : sizes) {
    for (auto j : sizes) {
      {
        T target;
        std::vector<bool> valid;
        doResize(target, valid, i);
        doResizeWithoutInit(target, valid, j);
        check(target);
      }

      {
        T target;
        std::vector<bool> valid;
        doResize(target, valid, i);
        doResizeWithoutInit(target, valid, j);
        doOverwrite(target, valid, i, j);
        check(target);
      }

      {
        T target;
        std::vector<bool> valid;
        doResizeWithoutInit(target, valid, i);
        doResize(target, valid, j);
        doOverwrite(target, valid, i / 2, i / 2);
        check(target);
      }

      {
        T target;
        std::vector<bool> valid;
        doResizeWithoutInit(target, valid, i);
        doResize(target, valid, j);
        doOverwrite(target, valid, i, j);
        check(target);
      }
    }
  }
}

template<typename T >

T validData	(	T const &	target,
		std::vector< bool > const &	valid
	)

Definition at line 64 of file UninitializedMemoryHacksTest.cpp.

References EXPECT_EQ, i, and T.

Referenced by doResize(), and doResizeWithoutInit().

                                                           {
  EXPECT_EQ(target.size(), valid.size());
  T rv;
  for (std::size_t i = 0; i < valid.size(); ++i) {
    if (valid[i]) {
      rv.push_back(target[i]);
    }
  }
  return rv;
}