ChecksumTest.cpp File Reference

#include <folly/hash/Checksum.h>
#include <boost/crc.hpp>
#include <folly/Benchmark.h>
#include <folly/Random.h>
#include <folly/hash/Hash.h>
#include <folly/hash/detail/ChecksumDetail.h>
#include <folly/portability/GFlags.h>
#include <folly/portability/GTest.h>

Go to the source code of this file.

Functions
	TEST (Checksum, crc32c_software)
	TEST (Checksum, crc32c_continuation_software)
	TEST (Checksum, crc32c_hardware)
	TEST (Checksum, crc32c_hardware_eq)
	TEST (Checksum, crc32c_continuation_hardware)
	TEST (Checksum, crc32c_autodetect)
	TEST (Checksum, crc32c_continuation_autodetect)
	TEST (Checksum, crc32)
	TEST (Checksum, crc32_continuation)
	TEST (Checksum, crc32_type)
	TEST (Checksum, crc32_combine)
	TEST (Checksum, crc32c_combine)
void	benchmarkHardwareCRC32C (unsigned long iters, size_t blockSize)
void	benchmarkSoftwareCRC32C (unsigned long iters, size_t blockSize)
void	benchmarkHardwareCRC32 (unsigned long iters, size_t blockSize)
void	benchmarkSoftwareCRC32 (unsigned long iters, size_t blockSize)
void	benchmarkCombineHardwareCrc32 (unsigned long iters, size_t blockSize)
void	benchmarkCombineSoftwareLinear (unsigned long iters, size_t blockSize)
void	benchmarkCombineHardwareCrc32c (unsigned long iters, size_t blockSize)
	BENCHMARK (crc32c_hardware_1KB_block, iters)
	BENCHMARK (crc32c_software_1KB_block, iters)
	BENCHMARK (crc32_hardware_1KB_block, iters)
	BENCHMARK (crc32_software_1KB_block, iters)
	BENCHMARK_DRAW_LINE ()
	BENCHMARK (crc32c_hardware_64KB_block, iters)
	BENCHMARK (crc32c_software_64KB_block, iters)
	BENCHMARK (crc32_hardware_64KB_block, iters)
	BENCHMARK (crc32_software_64KB_block, iters)
	BENCHMARK (crc32c_hardware_512KB_block, iters)
	BENCHMARK (crc32c_software_512KB_block, iters)
	BENCHMARK (crc32_hardware_512KB_block, iters)
	BENCHMARK (crc32_software_512KB_block, iters)
	BENCHMARK (crc32_combine_linear_512KB_block, iters)
	BENCHMARK (crc32_combine_512KB_block, iters)
	BENCHMARK (crc32c_combine_512KB_block, iters)
int	main (int argc, char **argv)

Function Documentation

BENCHMARK	(	crc32c_hardware_1KB_block	,
		iters
	)

Definition at line 306 of file ChecksumTest.cpp.

References benchmarkHardwareCRC32C().

                                            {
  benchmarkHardwareCRC32C(iters, 1024);
}

BENCHMARK	(	crc32c_software_1KB_block	,
		iters
	)

Definition at line 310 of file ChecksumTest.cpp.

References benchmarkSoftwareCRC32C().

                                            {
  benchmarkSoftwareCRC32C(iters, 1024);
}

BENCHMARK	(	crc32_hardware_1KB_block	,
		iters
	)

Definition at line 314 of file ChecksumTest.cpp.

References benchmarkHardwareCRC32().

                                           {
  benchmarkHardwareCRC32(iters, 1024);
}

BENCHMARK	(	crc32_software_1KB_block	,
		iters
	)

Definition at line 318 of file ChecksumTest.cpp.

References BENCHMARK_DRAW_LINE(), and benchmarkSoftwareCRC32().

                                           {
  benchmarkSoftwareCRC32(iters, 1024);
}

BENCHMARK	(	crc32c_hardware_64KB_block	,
		iters
	)

Definition at line 325 of file ChecksumTest.cpp.

References benchmarkHardwareCRC32C().

                                             {
  benchmarkHardwareCRC32C(iters, 64 * 1024);
}

BENCHMARK	(	crc32c_software_64KB_block	,
		iters
	)

Definition at line 329 of file ChecksumTest.cpp.

References benchmarkSoftwareCRC32C().

                                             {
  benchmarkSoftwareCRC32C(iters, 64 * 1024);
}

BENCHMARK	(	crc32_hardware_64KB_block	,
		iters
	)

Definition at line 333 of file ChecksumTest.cpp.

References benchmarkHardwareCRC32().

                                            {
  benchmarkHardwareCRC32(iters, 64 * 1024);
}

BENCHMARK	(	crc32_software_64KB_block	,
		iters
	)

Definition at line 337 of file ChecksumTest.cpp.

References BENCHMARK_DRAW_LINE(), and benchmarkSoftwareCRC32().

                                            {
  benchmarkSoftwareCRC32(iters, 64 * 1024);
}

BENCHMARK	(	crc32c_hardware_512KB_block	,
		iters
	)

Definition at line 344 of file ChecksumTest.cpp.

References benchmarkHardwareCRC32C().

                                              {
  benchmarkHardwareCRC32C(iters, 512 * 1024);
}

BENCHMARK	(	crc32c_software_512KB_block	,
		iters
	)

Definition at line 348 of file ChecksumTest.cpp.

References benchmarkSoftwareCRC32C().

                                              {
  benchmarkSoftwareCRC32C(iters, 512 * 1024);
}

BENCHMARK	(	crc32_hardware_512KB_block	,
		iters
	)

Definition at line 352 of file ChecksumTest.cpp.

References benchmarkHardwareCRC32().

                                             {
  benchmarkHardwareCRC32(iters, 512 * 1024);
}

BENCHMARK	(	crc32_software_512KB_block	,
		iters
	)

Definition at line 356 of file ChecksumTest.cpp.

References BENCHMARK_DRAW_LINE(), and benchmarkSoftwareCRC32().

                                             {
  benchmarkSoftwareCRC32(iters, 512 * 1024);
}

BENCHMARK	(	crc32_combine_linear_512KB_block	,
		iters
	)

Definition at line 362 of file ChecksumTest.cpp.

References benchmarkCombineSoftwareLinear().

                                                   {
  benchmarkCombineSoftwareLinear(iters, 512 * 1024);
}

BENCHMARK	(	crc32_combine_512KB_block	,
		iters
	)

Definition at line 366 of file ChecksumTest.cpp.

References benchmarkCombineHardwareCrc32().

                                            {
  benchmarkCombineHardwareCrc32(iters, 512 * 1024);
}

BENCHMARK	(	crc32c_combine_512KB_block	,
		iters
	)

Definition at line 370 of file ChecksumTest.cpp.

References benchmarkCombineHardwareCrc32c().

                                             {
  benchmarkCombineHardwareCrc32c(iters, 512 * 1024);
}

BENCHMARK_DRAW_LINE

(

)

Referenced by BENCHMARK().

void benchmarkCombineHardwareCrc32	(	unsigned long	iters,
		size_t	blockSize
	)

Definition at line 267 of file ChecksumTest.cpp.

References folly::crc32_combine(), folly::doNotOptimizeAway(), i, and uint32_t.

Referenced by BENCHMARK().

                                                                          {
  // Arbitrarily chosen checksums
  uint32_t checksum1 = 0xEDB88320;
  uint32_t checksum2 = 0x82F63B78;
  uint32_t result;
  for (unsigned long i = 0; i < iters; i++) {
    result = folly::crc32_combine(checksum1, checksum2, blockSize);
    folly::doNotOptimizeAway(result);
  }
}

void benchmarkCombineHardwareCrc32c	(	unsigned long	iters,
		size_t	blockSize
	)

Definition at line 293 of file ChecksumTest.cpp.

References folly::crc32c_combine(), folly::doNotOptimizeAway(), i, and uint32_t.

Referenced by BENCHMARK().

                                                                           {
  // Arbitrarily chosen checksums
  uint32_t checksum1 = 0xEDB88320;
  uint32_t checksum2 = 0x82F63B78;
  uint32_t result;
  for (unsigned long i = 0; i < iters; i++) {
    result = folly::crc32c_combine(checksum1, checksum2, blockSize);
    folly::doNotOptimizeAway(result);
  }
}

void benchmarkCombineSoftwareLinear	(	unsigned long	iters,
		size_t	blockSize
	)

Definition at line 278 of file ChecksumTest.cpp.

References folly::crc32c(), folly::doNotOptimizeAway(), i, and uint32_t.

Referenced by BENCHMARK().

                                                                           {
  // Arbitrarily chosen checksums
  std::vector<uint8_t> zbuffer;
  zbuffer.reserve(blockSize);
  memset(zbuffer.data(), 0, blockSize);
  uint32_t checksum1 = 0xEDB88320;
  uint32_t checksum2 = 0x82F63B78;
  uint32_t result;
  for (unsigned long i = 0; i < iters; i++) {
    result = folly::crc32c(zbuffer.data(), blockSize, checksum1);
    result ^= checksum2;
    folly::doNotOptimizeAway(result);
  }
}

void benchmarkHardwareCRC32	(	unsigned long	iters,
		size_t	blockSize
	)

Definition at line 246 of file ChecksumTest.cpp.

References folly::detail::crc32_hw(), folly::detail::crc32_hw_supported(), folly::doNotOptimizeAway(), i, and uint32_t.

Referenced by BENCHMARK().

                                                                   {
  if (folly::detail::crc32_hw_supported()) {
    uint32_t checksum;
    for (unsigned long i = 0; i < iters; i++) {
      checksum = folly::detail::crc32_hw(buffer, blockSize);
      folly::doNotOptimizeAway(checksum);
    }
  } else {
    LOG(WARNING) << "skipping hardware-accelerated CRC-32 benchmarks"
                 << " (not supported on this CPU)";
  }
}

void benchmarkHardwareCRC32C	(	unsigned long	iters,
		size_t	blockSize
	)

Definition at line 225 of file ChecksumTest.cpp.

References folly::detail::crc32c_hw(), folly::detail::crc32c_hw_supported(), folly::doNotOptimizeAway(), i, and uint32_t.

Referenced by BENCHMARK().

                                                                    {
  if (folly::detail::crc32c_hw_supported()) {
    uint32_t checksum;
    for (unsigned long i = 0; i < iters; i++) {
      checksum = folly::detail::crc32c_hw(buffer, blockSize);
      folly::doNotOptimizeAway(checksum);
    }
  } else {
    LOG(WARNING) << "skipping hardware-accelerated CRC-32C benchmarks"
                 << " (not supported on this CPU)";
  }
}

void benchmarkSoftwareCRC32	(	unsigned long	iters,
		size_t	blockSize
	)

Definition at line 259 of file ChecksumTest.cpp.

References folly::detail::crc32_sw(), folly::doNotOptimizeAway(), i, and uint32_t.

Referenced by BENCHMARK().

                                                                   {
  uint32_t checksum;
  for (unsigned long i = 0; i < iters; i++) {
    checksum = folly::detail::crc32_sw(buffer, blockSize);
    folly::doNotOptimizeAway(checksum);
  }
}

void benchmarkSoftwareCRC32C	(	unsigned long	iters,
		size_t	blockSize
	)

Definition at line 238 of file ChecksumTest.cpp.

References folly::detail::crc32c_sw(), folly::doNotOptimizeAway(), i, and uint32_t.

Referenced by BENCHMARK().

                                                                    {
  uint32_t checksum;
  for (unsigned long i = 0; i < iters; i++) {
    checksum = folly::detail::crc32c_sw(buffer, blockSize);
    folly::doNotOptimizeAway(checksum);
  }
}

int main	(	int	argc,
		char **	argv
	)

Definition at line 374 of file ChecksumTest.cpp.

References buffer(), folly::test::end(), folly::hash::fnv64_buf(), testing::InitGoogleTest(), RUN_ALL_TESTS(), folly::runBenchmarks(), uint64_t, and uint8_t.

                                {
  testing::InitGoogleTest(&argc, argv);
  gflags::ParseCommandLineFlags(&argc, &argv, true);

  // Populate a buffer with a deterministic pattern
  // on which to compute checksums
  const uint8_t* src = buffer;
  uint64_t* dst = (uint64_t*)buffer;
  const uint64_t* end = (const uint64_t*)(buffer + BUFFER_SIZE);
  *dst++ = 0;
  while (dst < end) {
    *dst++ = folly::hash::fnv64_buf((const char*)src, sizeof(uint64_t));
    src += sizeof(uint64_t);
  }

  auto ret = RUN_ALL_TESTS();
  if (!ret && FLAGS_benchmark) {
    folly::runBenchmarks();
  }
  return ret;
}

TEST	(	Checksum	,
		crc32c_software
	)

Definition at line 108 of file ChecksumTest.cpp.

References folly::detail::crc32c_sw().

                                {
  testCRC32C(folly::detail::crc32c_sw);
}

TEST	(	Checksum	,
		crc32c_continuation_software
	)

Definition at line 112 of file ChecksumTest.cpp.

References folly::detail::crc32c_sw().

                                             {
  testCRC32CContinuation(folly::detail::crc32c_sw);
}

TEST	(	Checksum	,
		crc32c_hardware
	)

Definition at line 116 of file ChecksumTest.cpp.

References folly::detail::crc32c_hw(), and folly::detail::crc32c_hw_supported().

                                {
  if (folly::detail::crc32c_hw_supported()) {
    testCRC32C(folly::detail::crc32c_hw);
  } else {
    LOG(WARNING) << "skipping hardware-accelerated CRC-32C tests"
                 << " (not supported on this CPU)";
  }
}

TEST	(	Checksum	,
		crc32c_hardware_eq
	)

Definition at line 125 of file ChecksumTest.cpp.

References folly::detail::crc32c_hw(), folly::detail::crc32c_hw_supported(), folly::detail::crc32c_sw(), EXPECT_EQ, and i.

                                   {
  if (folly::detail::crc32c_hw_supported()) {
    for (int i = 0; i < 1000; i++) {
      auto sw = folly::detail::crc32c_sw(buffer, i, 0);
      auto hw = folly::detail::crc32c_hw(buffer, i, 0);
      EXPECT_EQ(sw, hw);
    }
  } else {
    LOG(WARNING) << "skipping hardware-accelerated CRC-32C tests"
                 << " (not supported on this CPU)";
  }
}

TEST	(	Checksum	,
		crc32c_continuation_hardware
	)

Definition at line 138 of file ChecksumTest.cpp.

References folly::detail::crc32c_hw(), and folly::detail::crc32c_hw_supported().

                                             {
  if (folly::detail::crc32c_hw_supported()) {
    testCRC32CContinuation(folly::detail::crc32c_hw);
  } else {
    LOG(WARNING) << "skipping hardware-accelerated CRC-32C tests"
                 << " (not supported on this CPU)";
  }
}

TEST	(	Checksum	,
		crc32c_autodetect
	)

Definition at line 147 of file ChecksumTest.cpp.

References folly::crc32c().

                                  {
  testCRC32C(folly::crc32c);
}

TEST	(	Checksum	,
		crc32c_continuation_autodetect
	)

Definition at line 151 of file ChecksumTest.cpp.

References folly::crc32c().

                                               {
  testCRC32CContinuation(folly::crc32c);
}

TEST	(	Checksum	,
		crc32
	)

Definition at line 155 of file ChecksumTest.cpp.

References folly::detail::crc32_hw(), folly::detail::crc32_sw(), folly::detail::crc32c_hw_supported(), EXPECT_EQ, and uint32_t.

                      {
  if (folly::detail::crc32c_hw_supported()) {
    // Just check that sw and hw match
    for (auto expected : expectedResults) {
      uint32_t sw_res =
          folly::detail::crc32_sw(buffer + expected.offset, expected.length, 0);
      uint32_t hw_res =
          folly::detail::crc32_hw(buffer + expected.offset, expected.length, 0);
      EXPECT_EQ(sw_res, hw_res);
    }
  } else {
    LOG(WARNING) << "skipping hardware-accelerated CRC-32 tests"
                 << " (not supported on this CPU)";
  }
}

TEST	(	Checksum	,
		crc32_continuation
	)

Definition at line 171 of file ChecksumTest.cpp.

References folly::detail::crc32_hw(), folly::detail::crc32_sw(), folly::detail::crc32c_hw_supported(), EXPECT_EQ, and uint32_t.

                                   {
  if (folly::detail::crc32c_hw_supported()) {
    // Just check that sw and hw match
    for (auto expected : expectedResults) {
      auto halflen = expected.length / 2;
      uint32_t sw_res =
          folly::detail::crc32_sw(buffer + expected.offset, halflen, 0);
      sw_res = folly::detail::crc32_sw(
          buffer + expected.offset + halflen, halflen, sw_res);
      uint32_t hw_res =
          folly::detail::crc32_hw(buffer + expected.offset, halflen, 0);
      hw_res = folly::detail::crc32_hw(
          buffer + expected.offset + halflen, halflen, hw_res);
      EXPECT_EQ(sw_res, hw_res);
      uint32_t sw_res2 =
          folly::detail::crc32_sw(buffer + expected.offset, halflen * 2, 0);
      EXPECT_EQ(sw_res, sw_res2);
      uint32_t hw_res2 =
          folly::detail::crc32_hw(buffer + expected.offset, halflen * 2, 0);
      EXPECT_EQ(hw_res, hw_res2);
    }
  } else {
    LOG(WARNING) << "skipping hardware-accelerated CRC-32 tests"
                 << " (not supported on this CPU)";
  }
}

TEST	(	Checksum	,
		crc32_type
	)

Definition at line 198 of file ChecksumTest.cpp.

                           {
  // Test that crc32_type matches boost::crc_32_type
  testMatchesBoost32Type();
}

TEST	(	Checksum	,
		crc32_combine
	)

Definition at line 203 of file ChecksumTest.cpp.

References folly::crc32(), folly::crc32_combine(), EXPECT_EQ, and folly::Random::rand64().

                              {
  for (size_t totlen = 1024; totlen < BUFFER_SIZE; totlen += BUFFER_SIZE / 8) {
    auto mid = folly::Random::rand64(0, totlen);
    auto crc1 = folly::crc32(&buffer[0], mid, 0);
    auto crc2 = folly::crc32(&buffer[mid], totlen - mid, 0);
    auto crcfull = folly::crc32(&buffer[0], totlen, 0);
    auto combined = folly::crc32_combine(crc1, crc2, totlen - mid);
    EXPECT_EQ(combined, crcfull);
  }
}

TEST	(	Checksum	,
		crc32c_combine
	)

Definition at line 214 of file ChecksumTest.cpp.

References folly::crc32c(), folly::crc32c_combine(), EXPECT_EQ, and folly::Random::rand64().

                               {
  for (size_t totlen = 1024; totlen < BUFFER_SIZE; totlen += BUFFER_SIZE / 8) {
    auto mid = folly::Random::rand64(0, totlen);
    auto crc1 = folly::crc32c(&buffer[0], mid, 0);
    auto crc2 = folly::crc32c(&buffer[mid], totlen - mid, 0);
    auto crcfull = folly::crc32c(&buffer[0], totlen, 0);
    auto combined = folly::crc32c_combine(crc1, crc2, totlen - mid);
    EXPECT_EQ(combined, crcfull);
  }
}