claunia/findcrcs
1
0
Fork 0
mirror of https://github.com/claunia/findcrcs.git synced 2025-12-16 10:44:25 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
b5e1635fe3eeffd7a90ebe7d779f827c42c0944b
findcrcs/crcutil-1.0/tests/unittest.h

1106 lines
33 KiB
C++
Raw Blame History

// Copyright 2010 Google Inc. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Functionality and performance tests of available CRC implementations.
#ifndef CRCUTIL_UNITTEST_H_
#define CRCUTIL_UNITTEST_H_
#if defined(_MSC_VER)
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(push)
#pragma warning(disable: 4820) // structure was padded
#pragma warning(disable: 4710) // function not inlined
// C++ exception handler used, but unwind
// semantics are not enabled. Specify /EHsc
#pragma warning(disable: 4530)
#endif // defined(_MSC_VER)
#include <map>
#include <set>
#include <string>
#if defined(_MSC_VER)
#pragma warning(pop)
#endif // defined(_MSC_VER)
#include "aligned_alloc.h"
#include "bob_jenkins_rng.h"
#include "crc32c_sse4.h"
#include "generic_crc.h"
#include "rdtsc.h"
#include "rolling_crc.h"
#include "unittest_helper.h"
namespace crcutil {
#if defined(_INTEL_COMPILER)
#pragma warning(push)
#pragma warning(disable: 185) // dynamic initialization in unreachable code
#endif // defined(_INTEL_COMPILER)
#if HAVE_AMD64 || HAVE_I386
class Crc32cSSE4_Test : public Crc32cSSE4 {
public:
void *operator new(size_t, void *p) {
return p;
}
};
template<typename Crc, typename TableEntry, typename Word, int kStride>
class GenericCrcTest : public GenericCrc<Crc, TableEntry, Word, kStride> {
public:
~GenericCrcTest() {
AlignedFree(aligned_memory_);
}
void InitWithCrc32c(const Crc &generating_polynomial,
size_t degree,
bool constant) {
this->Init(generating_polynomial, degree, constant);
crc32c_ = NULL;
aligned_memory_ = NULL;
// Bug in GCC 4.4.3: if (kStride == 4) comparison is put first
// so that the compiler may optimize out entire "if" statement,
// GCC 4.4.3 at -O3 level generates incorrect code corrupting "this".
if (degree == Crc32cSSE4::FixedDegree() &&
generating_polynomial == Crc32cSSE4::FixedGeneratingPolynomial() &&
(!CRCUTIL_USE_MM_CRC32 || Crc32cSSE4::IsSSE42Available()) &&
kStride == 4 &&
sizeof(Crc) == sizeof(size_t)) {
aligned_memory_ = AlignedAlloc(sizeof(*crc32c_), 0, 256, NULL);
crc32c_ = new(aligned_memory_) Crc32cSSE4_Test;
crc32c_->Init(constant);
}
}
bool HaveCrc32c() const {
return (crc32c_ != NULL);
}
Crc CRC32C(const void *data, size_t bytes, const Crc &start) const {
return static_cast<Crc>(
crc32c_->CrcDefault(data, bytes, Downcast<Crc, size_t>(start)));
}
private:
Crc32cSSE4_Test *crc32c_;
void *aligned_memory_;
};
#else
template<typename Crc, typename TableEntry, typename Word, int kStride>
class GenericCrcTest : public GenericCrc<Crc, TableEntry, Word, kStride> {
public:
~GenericCrcTest() {}
void InitWithCrc32c(const Crc &generating_polynomial,
size_t degree,
bool constant) {
Init(generating_polynomial, degree, constant);
}
bool HaveCrc32c() const {
return false;
}
Crc CRC32C(const void * /* data */,
size_t /* bytes */,
const Crc & /* start */) const {
return 0;
}
};
#endif // HAVE_AMD64 || HAVE_I386
// Forward declaration.
class PerfTestState;
class CrcVerifierInterface {
public:
virtual void TestFunctionality(const char *class_title) const = 0;
virtual void TestPerformance(FILE *output,
PerfTestState *state,
bool multiword_only,
const char *class_title) = 0;
CrcVerifierInterface() {}
protected:
virtual ~CrcVerifierInterface() {}
};
// Finds the most efficient implementation algorithm for
// given CRC.
class AlgSorter {
public:
void Add(std::string crc_name, std::string alg_name, double cycles) {
CrcInfo *crc_info = crcs_[crc_name];
if (crc_info == NULL) {
crc_info = new CrcInfo;
crcs_[crc_name] = crc_info;
}
AlgStat *alg_stat = (*crc_info)[alg_name];
if (alg_stat == NULL) {
alg_stat = new AlgStat;
alg_stat->name = alg_name;
alg_stat->cycles = 0;
alg_stat->tests = 0;
(*crc_info)[alg_name] = alg_stat;
}
alg_stat->cycles += cycles;
alg_stat->tests += 1;
}
void PrintBest() {
for (Crcs::const_iterator it = crcs_.begin(); it != crcs_.end(); ++it) {
PrintBestCrc(it->first, *(it->second));
}
}
private:
struct AlgStat {
std::string name;
double cycles;
int tests;
};
typedef std::map<std::string, AlgStat *> CrcInfo;
typedef std::map<std::string, CrcInfo *> Crcs;
struct AlgStatCompare {
bool operator()(const AlgStat *a, const AlgStat *b) const {
return ((a->cycles / a->tests) < (b->cycles / b->tests));
}
};
void PrintBestCrc(std::string crc_name, const CrcInfo &crc_info) {
typedef std::set<AlgStat *, AlgStatCompare> SortedAlgStat;
SortedAlgStat alg_set;
for (CrcInfo::const_iterator it = crc_info.begin();
it != crc_info.end();
++it) {
alg_set.insert(it->second);
}
printf("%s\n", crc_name.c_str());
for (SortedAlgStat::const_iterator it = alg_set.begin();
it != alg_set.end();
++it) {
printf(" %-28s %6.3f cycles/byte\n",
(*it)->name.c_str(),
(*it)->cycles / (*it)->tests);
}
printf("\n");
}
Crcs crcs_;
};
class PerfTestState {
public:
enum {
MAX_TEST_COUNT = 100,
};
explicit PerfTestState(FILE *output)
: output_(output), test_count_(0), title_printed_(false) {}
~PerfTestState() {}
void Add(uint32 bytes, const char *name, double cycles) {
if (test_count_ < MAX_TEST_COUNT) {
bytes_ = bytes;
test_[test_count_].name = name;
test_[test_count_].cycles = cycles;
test_count_ += 1;
}
if (bytes >= 1024 && bytes <= 1024 * 1024 &&
memcmp(name, "MemSpeed", 9) != 0) {
crc_sorter_.Add(crc_name_, std::string(name) + "-" + alg_name_, cycles);
}
}
void Print() {
if (!title_printed_) {
for (size_t i = 0; i < test_count_; ++i) {
fprintf(output_, ", %s", test_[i].name);
}
fprintf(output_, ",, BestTime, BestMethod");
fprintf(output_, "\n");
fflush(output_);
title_printed_ = true;
}
double min_cycles = 1e30;
size_t min_index = 0;
fprintf(output_, "%9u", bytes_);
for (size_t i = 0; i < test_count_; ++i) {
fprintf(output_, ", %6.3f", test_[i].cycles);
if (min_cycles > test_[i].cycles &&
memcmp(test_[i].name, "MemSpeed", 9) != 0) {
min_cycles = test_[i].cycles;
min_index = i + 1;
}
}
if (min_index != 0) {
min_index -= 1;
fprintf(output_,
",, %6.3f, %s",
test_[min_index].cycles,
test_[min_index].name);
}
fprintf(output_, "\n");
fflush(output_);
test_count_ = 0;
}
void Finish() {
fprintf(output_, "\n");
fflush(output_);
test_count_ = 0;
title_printed_ = false;
}
void StartNewCrc(const char *name) {
// Assuming the name is in following format:
// CRC-NNN-ALG-MODE where
// NNN - CRC width
// ALG - algorithm
// MODE - mode (raw or canonical)
const char *second_dash;
second_dash = strchr(name, '-');
if (second_dash != NULL) {
second_dash = strchr(second_dash + 1, '-');
}
if (second_dash == NULL) {
second_dash = name + strlen(name);
}
std::string str_name(name, static_cast<size_t>(second_dash - name));
crc_name_ = str_name;
if (*second_dash == '-') {
++second_dash;
}
const char *last_dash = strrchr(second_dash, '-');
if (last_dash == NULL) {
last_dash = name + strlen(name);
}
std::string str_alg_name(second_dash,
static_cast<size_t>(last_dash - second_dash));
alg_name_ = str_alg_name;
}
void PrintBest() {
crc_sorter_.PrintBest();
}
private:
PerfTestState();
FILE *output_;
size_t test_count_;
bool title_printed_;
uint32 bytes_;
struct {
const char *name;
double cycles;
} test_[MAX_TEST_COUNT];
std::string crc_name_;
std::string alg_name_;
AlgSorter crc_sorter_;
};
template<typename CrcImplementation>
class RollingCrcTest
: public RollingCrc<CrcImplementation> {
public:
void *operator new(size_t, void *p) {
return p;
}
};
template<typename Crc, typename TableEntry, typename Word, int kStride>
class CrcTest : public GenericCrcTest<Crc, TableEntry, Word, kStride>,
public CrcVerifierInterface {
public:
typedef CrcTest<Crc, TableEntry, Word, kStride> CrcTestSelf;
typedef RollingCrcTest< GenericCrc<Crc, TableEntry, Word, kStride> >
RollingCrcSelf;
typedef Crc(CrcTestSelf::*CrcCallback) (
const void *data, size_t bytes, const Crc &start) const;
void *operator new(size_t, void *p) {
return p;
}
void VerifyPow() const {
Crc x = this->Base().One() >> 1;
Crc x_pow_i = x;
for (size_t i = 1; i < 1024; ++i) {
Crc value = this->Base().XpowN(i);
CHECK_EQ(x_pow_i, value);
x_pow_i = this->Base().Multiply(x_pow_i, x);
}
}
void VerifyCrcZeroes() const {
uint8 buf[256];
memset(buf, 0, sizeof(buf));
for (size_t k = 0; k < 256; ++k) {
Crc zero_old = this->CrcByte(buf, k, 1);
Crc zero_new = this->Base().CrcOfZeroes(k, 1);
CHECK_EQ(zero_old, zero_new);
}
}
void VerifyChangeStartValue() const {
#if defined(_MSC_VER) && _MSC_FULL_VER <= 150030729 && defined(_M_IX86)
// Work around a bug in CL.
if (sizeof(Crc) > 8) {
return;
}
#endif // defined(_MSC_VER) && _MSC_FULL_VER < 150030729 && defined(_M_IX86)
uint8 buf[256];
BobJenkinsRng<size_t> rng;
for (size_t i = 0; i < 256; ++i) {
buf[i] = static_cast<uint8>(rng.Get());
}
for (size_t n = 1; n < 256 && (n >> this->Base().Degree()) == 0; ++n) {
for (size_t i = 0;
i < 4096 && (i >> this->Base().Degree()) == 0;
i += 11) {
Crc crc_old = this->CrcByte(buf, n, 0);
Crc crc_new = this->CrcByte(buf, n, static_cast<Crc>(i));
Crc crc_chg = this->Base().ChangeStartValue(crc_old, n, 0,
static_cast<Crc>(i));
CHECK_EQ(crc_new, crc_chg);
}
}
}
void VerifyConcatenate() const {
#if defined(_MSC_FULL_VER) && _MSC_FULL_VER <= 150030729 && defined(_M_IX86)
// Work around a bug in CL
if (sizeof(Crc) > 8) {
return;
}
#endif
uint8 buf[256];
BobJenkinsRng<size_t> rng;
for (size_t i = 0; i < 256; ++i) {
buf[i] = static_cast<uint8>(rng.Get());
}
for (size_t n = 1; n < 256; ++n) {
for (size_t i = 0; i < n; ++i) {
if (((i + 1) >> this->Base().Degree()) != 0) {
break;
}
Crc startA = static_cast<Crc>(i + 1);
Crc crc_A = this->CrcByte(buf, i, startA);
Crc crc_B = this->CrcByte(buf + i, n - i, 0);
Crc crc_AB = this->CrcByte(buf, n, startA);
Crc crc = this->Base().Concatenate(crc_A, crc_B, n - i);
CHECK_EQ(crc_AB, crc);
}
}
}
void VerifyCb(CrcCallback cb, const char *test_name) const {
uint8 buf[256];
fprintf(stderr, " %s\n", test_name);
fflush(stderr);
// See whether it handles 0 bytes correctly.
(this->*cb)(NULL, 0, 0);
BobJenkinsRng<size_t> rng;
for (size_t n = 0; n < 256; ++n) {
memset(buf, 0, sizeof(buf));
// Check "lonely 1" pattern.
for (size_t k = 0; k < n; ++k) {
buf[k] = 0x80;
Crc crc_old = this->CrcByte(buf, n, 0);
Crc crc_new = (this->*cb)(buf, n, 0);
CHECK_EQ(crc_old, crc_new);
buf[k] = 0;
}
// Check "lonely random byte" pattern.
for (size_t k = 0; k < n; ++k) {
buf[k] = static_cast<uint8>(rng.Get());
Crc crc_old = this->CrcByte(buf, n, 0);
Crc crc_new = (this->*cb)(buf, n, 0);
CHECK_EQ(crc_old, crc_new);
buf[k] = 0;
}
// Check "starts from sequence of 1s" pattern.
for (size_t k = 0; k < n; ++k) {
buf[k] = 0x80;
Crc crc_old = this->CrcByte(buf, n, 0);
Crc crc_new = (this->*cb)(buf, n, 0);
CHECK_EQ(crc_old, crc_new);
}
// Check "starts from sequence of random bytes" pattern.
memset(buf, 0, sizeof(buf));
for (size_t k = 0; k < n; ++k) {
buf[k] = static_cast<uint8>(rng.Get());
Crc crc_old = this->CrcByte(buf, n, 0);
Crc crc_new = (this->*cb)(buf, n, 0);
CHECK_EQ(crc_old, crc_new);
}
}
// Check that alignment is handled correctly.
for (size_t n = 0; n < 256; ++n) {
buf[n] = static_cast<uint8>(rng.Get());
for (size_t k = 0; k < n; ++k) {
Crc crc_old = this->CrcByte(buf + k, n - k, 0);
Crc crc_new = (this->*cb)(buf + k, n - k, 0);
CHECK_EQ(crc_old, crc_new);
}
}
// Now, do randomized tests.
size_t buffer_size = 128 * 1024;
uint8 *buffer = new uint8[buffer_size];
for (size_t i = 0; i < buffer_size; ++i) {
buffer[i] = static_cast<uint8>(rng.Get());
}
for (size_t i = 0; i < 1 * 1000; ++i) {
size_t bytes = rng.Get() % (buffer_size - 1);
size_t offset = rng.Get() % (buffer_size - bytes);
Crc crc_old = this->CrcByte(buffer + offset, bytes, 0);
Crc crc_new = (this->*cb)(buffer + offset, bytes, 0);
CHECK_EQ(crc_old, crc_new);
}
delete[] buffer;
}
void VerifyLCD() const {
Crc A;
Crc B;
Crc LCD;
for (A = this->Base().One(); A != 0; A >>= 1) {
LCD = this->Base().FindLCD(A, &B);
CHECK_EQ(this->Base().One(), LCD);
Crc product = this->Base().Multiply(A, B);
CHECK_EQ(this->Base().One(), product);
}
int rept = 253;
uint64 step = static_cast<uint64>(1);
size_t degree = this->Base().Degree();
if (degree > 64) degree = 62;
step = (step << degree) / rept;
uint64 value = step;
for (; --rept; value += step) {
A = static_cast<Crc>(value);
LCD = this->Base().FindLCD(A, &B);
if (LCD == this->Base().One()) {
Crc product = this->Base().Multiply(A, B);
CHECK_EQ(this->Base().One(), product);
}
uint8 buf[64];
size_t bytes = this->Base().StoreCrc(buf, A);
Crc result = this->CrcByte(buf, bytes, A);
CHECK_EQ(this->Base().CrcOfCrc(), result);
bytes = this->Base().StoreComplementaryCrc(buf, A, 0);
result = this->CrcByte(buf, bytes, A);
CHECK_EQ(result, 0);
}
}
void VerifyCrcOfCrc(void) const {
Crc A;
int rept = 253;
uint64 step = static_cast<uint64>(1);
size_t degree = this->Base().Degree();
if (degree > 64) degree = 62;
step = (step << degree) / rept;
Crc expected = this->Base().CrcOfCrc();
uint64 value = step;
for (; --rept; value += step) {
A = static_cast<Crc>(value);
Crc value = this->CrcByte(&A, (this->Base().Degree() + 7) >> 3, A);
CHECK_EQ(expected, value);
}
}
void VerifyDistribution() const {
Crc coef = this->Base().One();
for (int index = 0; coef != 0; ++index, coef >>= 1) {
int ones = 0;
for (int i = 0; i < 256; ++i) {
if ((this->crc_word_[sizeof(Word) - 1][i] & coef) == 0) {
ones += 1;
}
}
CHECK_EQ(128, ones);
}
}
void VerifyRollingCrc() const {
void *aligned_memory = AlignedAlloc(sizeof(RollingCrcSelf), 0, 256, NULL);
RollingCrcSelf *rolling_crc = new(aligned_memory) RollingCrcSelf;
static const size_t kMaxRollBytes = 8;
static const size_t kBufferSize = 256 + kMaxRollBytes;
uint8 buffer[kBufferSize];
for (size_t starting_value = 0;
starting_value < 256 &&
(starting_value >> this->Base().Degree()) == 0;
++starting_value) {
for (size_t roll_bytes = 1;
roll_bytes < kMaxRollBytes;
++roll_bytes) {
rolling_crc->Init(*this, roll_bytes, static_cast<Crc>(starting_value));
memset(buffer, 0, sizeof(buffer));
Crc old_crc = rolling_crc->Start(buffer);
for (size_t offset = roll_bytes; offset < kBufferSize; ++offset) {
Crc new_crc = rolling_crc->Roll(old_crc,
buffer[offset - roll_bytes],
buffer[offset]);
Crc vfy_crc = this->CrcByte(buffer + offset - roll_bytes + 1,
roll_bytes,
static_cast<Crc>(starting_value));
CHECK_EQ(new_crc, vfy_crc);
}
for (size_t offset = roll_bytes; offset < kBufferSize; ++offset) {
buffer[offset] = static_cast<uint8>(offset);
Crc new_crc = rolling_crc->Roll(old_crc,
buffer[offset - roll_bytes],
buffer[offset]);
Crc vfy_crc = this->CrcByte(buffer + offset - roll_bytes + 1,
roll_bytes,
static_cast<Crc>(starting_value));
CHECK_EQ(new_crc, vfy_crc);
old_crc = new_crc;
}
}
}
AlignedFree(aligned_memory);
}
virtual void TestFunctionality(const char *class_title) const {
fprintf(stderr,
"Functional test of %s (size=%u bytes",
class_title,
static_cast<int>(
sizeof(GenericCrc<Crc, TableEntry, Word, kStride>)));
if (this->HaveCrc32c()) {
fprintf(stderr, " [generic], %u bytes [CRC32C]",
static_cast<int>(sizeof(Crc32cSSE4)));
}
fprintf(stderr, ")\n");
fflush(stderr);
VerifyPow();
VerifyCb(&CrcTestSelf::CrcByteUnrolled, "ByteUnrolled");
VerifyCb(&CrcTestSelf::CrcByteWord, "ByteWord");
VerifyCb(&CrcTestSelf::CrcWord, "Word");
VerifyCb(&CrcTestSelf::CrcBlockword, "Blockword");
VerifyCb(&CrcTestSelf::CrcMultiword, "Multiword");
if (this->HaveCrc32c()) {
VerifyCb(&CrcTestSelf::CRC32C, "CRC32C");
}
VerifyLCD();
VerifyCrcZeroes();
VerifyChangeStartValue();
VerifyConcatenate();
VerifyCrcOfCrc();
VerifyDistribution();
VerifyRollingCrc();
fprintf(stderr, "\n");
fflush(stderr);
}
// MemSpeed sets the lowest threshold: it is necessary to touch
// CRC table at least once per input byte -- and it is necessary
// to touch all input bytes.
Crc MemSpeed(const void *data, size_t bytes, const Crc &start) const {
const uint8 *src = static_cast<const uint8 *>(data);
const uint8 *end = src + bytes;
Crc crc0 = start ^ this->Base().Canonize();
size_t buf0 = 0;
end -= 4 * sizeof(Word) - 1;
if (src < end) {
Crc crc1 = 0;
Crc crc2 = 0;
Crc crc3 = 0;
do {
for (size_t byte = 0; byte < sizeof(Word); ++byte) {
crc0 ^= this->crc_word_interleaved_[0][0 * 64];
crc1 ^= this->crc_word_interleaved_[1][1 * 64];
crc2 ^= this->crc_word_interleaved_[2][2 * 64];
crc3 ^= this->crc_word_interleaved_[3][3 * 64];
buf0 ^= src[byte * sizeof(Word)];
}
src += 4 * sizeof(Word);
} while (src < end);
crc0 ^= crc1 ^ crc2 ^ crc3;
}
end += 4 * sizeof(Word) - 1;
end -= sizeof(Word) - 1;
while (src < end) {
buf0 ^= *src;
src += sizeof(Word);
for (size_t byte = 0; byte < sizeof(Word); ++byte) {
crc0 ^= this->crc_word_interleaved_[0][0];
}
}
end += sizeof(Word) - 1;
while (src < end) {
buf0 ^= *src;
src += 1;
crc0 ^= this->crc_word_interleaved_[0][0];
}
return (crc0 ^ static_cast<Crc>(buf0));
}
void PerfTestCall(const uint8 *buf, size_t bytes, size_t rept,
CrcCallback cb, const Crc &expected_crc) const {
for (size_t r = 0; r < rept; ++r) {
Crc crc = (this->*cb)(buf, bytes, 0);
if (cb != &CrcTestSelf::MemSpeed) {
CHECK_EQ(expected_crc, crc);
}
}
}
uint64 PerfTestMeasure(const uint8 *buf, size_t bytes, size_t rept,
size_t tries, CrcCallback cb, const Crc &expected_crc) const {
uint64 min_time = ~0ULL;
for (size_t i = 0; i < tries; ++i) {
uint64 t = Rdtsc::Get();
PerfTestCall(buf, bytes, rept, cb, expected_crc);
t = Rdtsc::Get() - t;
if (min_time > t) {
min_time = t;
}
}
return min_time;
}
static const char *CompilerName() {
#define EXPANDED_STRINGIZE(c) #c
#define STRINGIZE(c) EXPANDED_STRINGIZE(c)
#if defined(__GNUC__)
return "GCC-" STRINGIZE(__GNUC__) "." STRINGIZE(__GNUC_MINOR__) "."
STRINGIZE(__GNUC_PATCHLEVEL__);
#elif defined(__INTEL_COMPILER)
return "ICL-" STRINGIZE(__INTEL_COMPILER);
#elif defined(_MSC_FULL_VER)
return "CL-" STRINGIZE(_MSC_FULL_VER);
#else
return "Unknown";
#endif
#undef EXPANDED_STRINGIZE
#undef STRINGIZE
}
void PerfTest(PerfTestState *state,
const uint8 *buf, uint32 bytes,
CrcCallback cb, const char *title) const {
Crc expected_crc = this->CrcByte(buf, bytes, 0);
size_t tries = (64 * 1024 * 1024 + bytes - 1) / bytes;
if (tries < 20) {
tries = 20;
} else if (tries > 1000) {
tries = 1000;
}
size_t rept = (128 * 1024 * 1024 + tries*bytes - 1) / (tries*bytes);
if (rept > 10000) {
rept = 10000;
}
uint64 min_time = PerfTestMeasure(buf, bytes, rept, tries, cb,
expected_crc);
state->Add(bytes, title, min_time / (static_cast<double>(rept) * bytes));
fflush(stderr);
}
uint64 PerfTestMeasureInit() {
uint64 min_time = 0;
min_time = ~min_time;
for (size_t i = 0; i < 5; ++i) {
uint64 t = Rdtsc::Get();
this->InitWithCrc32c(this->Base().GeneratingPolynomial(),
this->Base().Degree(),
this->Base().Canonize() != 0);
t = Rdtsc::Get() - t;
if (min_time > t) {
min_time = t;
}
}
return min_time;
}
void PerfTestVariants(PerfTestState *state,
bool test_multiword_only,
const uint8 *buf, uint32 buf_bytes,
uint32 bytes) const {
if (bytes > buf_bytes) {
return;
}
if (!test_multiword_only) {
PerfTest(state, buf, bytes,
&CrcTestSelf::MemSpeed, "MemSpeed");
PerfTest(state, buf, bytes,
&CrcTestSelf::CrcByte, "Byte");
PerfTest(state, buf, bytes,
&CrcTestSelf::CrcByteUnrolled, "ByteUnrolled");
PerfTest(state, buf, bytes,
&CrcTestSelf::CrcByteWord, "ByteWord");
PerfTest(state, buf, bytes,
&CrcTestSelf::CrcWord, "Word");
}
PerfTest(state, buf, bytes,
&CrcTestSelf::CrcBlockword, "Blockword");
PerfTest(state, buf, bytes,
&CrcTestSelf::CrcMultiword, "Multiword");
if (this->HaveCrc32c()) {
PerfTest(state, buf, bytes,
&CrcTestSelf::CRC32C, "CRC32C");
}
state->Print();
}
void PerfTestRun(FILE *output,
PerfTestState *state,
bool multiword_only,
uint8 *buf,
int align,
uint32 buf_bytes) {
BobJenkinsRng<size_t> rng;
for (size_t i = 0; i < buf_bytes; ++i) {
buf[i] = static_cast<uint8>(rng.Get());
}
fprintf(output, "ClassTitle, %s\n", class_title_);
fprintf(output,
"%12s, %7s, %6s, %3s, %11s, %4s, %6s, %9s, %10s, %10s\n",
"Compiler",
"CpuBits",
"Degree",
"Crc",
"TableEntry",
"Word",
"Stride",
"Alignment",
"TableBytes",
"InitCycles");
fprintf(output,
"%12s, %7d, %6d, %3d, %11d, %4d, %6d, %9d, %10d, %10d\n",
CompilerName(),
static_cast<int>(sizeof(size_t) * 8),
static_cast<int>(this->Base().Degree()),
static_cast<int>(sizeof(Crc)),
static_cast<int>(sizeof(TableEntry)),
static_cast<int>(sizeof(Word)),
static_cast<int>(kStride),
static_cast<int>(align),
static_cast<int>(sizeof(CrcTestSelf)),
static_cast<int>(PerfTestMeasureInit()));
fprintf(output, "\n");
fflush(output);
state->StartNewCrc(class_title_);
for (uint32 i = 4; i <= 64 * 1024 * 1024; i *= 2) {
PerfTestVariants(state, multiword_only, buf, buf_bytes, i);
}
state->Finish();
#if defined(FULL_PERF_TEST)
// Needed for performance work only.
for (uint32 i = 1; i <= 128; ++i) {
PerfTestVariants(state, multiword_only, buf, buf_bytes, i);
}
state->Finish();
#endif // defined(FULL_PERF_TEST)
}
void TestPerformance(FILE *output,
PerfTestState *state,
bool multiword_only,
const char *class_title) {
class_title_ = class_title;
uint32 align = sizeof(Word);
uint32 buf_bytes = 64*1024*1024;
uint8 *buf0 = new uint8[buf_bytes + align*2];
uint8 *buf = buf0;
if ((reinterpret_cast<size_t>(buf) & (align - 1)) != 0) {
buf += align - (reinterpret_cast<size_t>(buf) & (align - 1));
}
PerfTestRun(output, state, multiword_only, buf, 0, buf_bytes);
#if defined(FULL_PERF_TEST)
// Needed for performance work only.
PerfTestRun(output,
state,
multiword_only,
buf + sizeof(Word)/2,
sizeof(Word)/2,
buf_bytes);
#endif // defined(FULL_PERF_TEST)
delete[] buf;
}
private:
const char *class_title_;
};
class CrcVerifierFactoryInterface {
public:
virtual CrcVerifierInterface *Create(void *memory) const = 0;
virtual size_t TellMemoryBytesNeeded() const = 0;
virtual const char *class_title() const = 0;
virtual bool test_performance() const = 0;
virtual bool multiword_only() const = 0;
CrcVerifierFactoryInterface() {}
virtual ~CrcVerifierFactoryInterface() {}
};
// Verifies functionality of all registered CRCs first
// and only then runs time-consuming performance tests.
// That is helpful during development: we do not want to wait for
// all performance tests to go through but still want to do full
// functionality test.
class CrcVerifier {
public:
CrcVerifier() : memory_needed_(0), factory_count_(0) {}
void add(const CrcVerifierFactoryInterface *factory) {
if (factory_count_ < MAX_FACTORY_COUNT) {
factory_[factory_count_] = factory;
factory_count_ += 1;
size_t memory_needed = factory->TellMemoryBytesNeeded();
if (memory_needed_ < memory_needed) {
memory_needed_ = memory_needed;
}
}
}
void TestFunctionality() {
fprintf(stderr, "Verifying functionality\n");
fflush(stderr);
memory_allocate();
for (size_t i = 0; i < factory_count_; ++i) {
const CrcVerifierFactoryInterface *factory = factory_[i];
const CrcVerifierInterface *instance = factory->Create(aligned_memory_);
instance->TestFunctionality(factory->class_title());
}
memory_release();
}
void TestPerformance() {
fprintf(stderr, "Verifying performance\n");
fflush(stderr);
FILE *output = stdout;
PerfTestState state(output);
memory_allocate();
for (size_t i = 0; i < factory_count_; ++i) {
const CrcVerifierFactoryInterface *factory = factory_[i];
if (!factory->test_performance()) {
continue;
}
CrcVerifierInterface *instance = factory->Create(aligned_memory_);
instance->TestPerformance(output,
&state,
factory->multiword_only(),
factory->class_title());
}
state.PrintBest();
memory_release();
}
~CrcVerifier() {
for (size_t i = 0; i < factory_count_; ++i) {
delete factory_[i];
}
}
private:
void memory_allocate() {
aligned_memory_ = AlignedAlloc(memory_needed_, 0, 256, NULL);
}
void memory_release() {
AlignedFree(aligned_memory_);
}
enum {
MAX_FACTORY_COUNT = 100,
};
void *aligned_memory_;
size_t memory_needed_;
size_t factory_count_;
const CrcVerifierFactoryInterface *factory_[MAX_FACTORY_COUNT];
};
// Provides a factory creating ins
//
template<typename Crc, typename TableEntry, typename Word, size_t kStride>
class CrcVerifierFactory : public CrcVerifierFactoryInterface {
public:
typedef CrcTest<Crc, TableEntry, Word, kStride> CrcTestSelf;
typedef CrcVerifierFactory<Crc, TableEntry, Word, kStride>
CrcVerifierFactorySelf;
CrcVerifierFactory(bool constant, size_t degree,
uint64 poly_hi, uint64 poly_lo,
const char *class_title,
bool test_performance,
bool multiword_only)
: degree_(degree),
constant_(constant),
test_performance_(test_performance),
multiword_only_(multiword_only) {
strcpy(class_title_, class_title);
// On 32-bit platforms, "this" may be misaligned with respect
// to sizeof(Crc) -- even though alignment of the structure is
// correct (e.g. 16 when Crc=uint128_sse2), "new" returns memory
// that is aligned on 8 boundary only. Respectively, attempt
// to access a field of Crc type when Crc=uint128_sse2 fails.
//
// Use local variable and memcpy to access fields of Crc type.
//
Crc generating_polynomial = CrcFromUint64<Crc>(poly_lo, poly_hi);
memcpy(&generating_polynomial_, &generating_polynomial, sizeof(Crc));
}
virtual CrcVerifierInterface *Create(void *memory) const {
CrcTestSelf *crc = new(memory) CrcTestSelf;
// "this" may be misaligned on 32-bit platforms.
// Use local variable and memcpy to access fields of Crc type.
Crc generating_polynomial;
memcpy(&generating_polynomial, &generating_polynomial_, sizeof(Crc));
crc->InitWithCrc32c(generating_polynomial, degree_, constant_);
return crc;
}
virtual size_t TellMemoryBytesNeeded() const {
return sizeof(CrcTestSelf);
}
const char *class_title() const { return class_title_; }
bool test_performance() const { return test_performance_; }
bool multiword_only() const { return multiword_only_; }
private:
CrcVerifierFactory() {}
const CrcVerifierFactory &operator=(const CrcVerifierFactory &src);
Crc generating_polynomial_;
char class_title_[128];
size_t const degree_;
bool const constant_;
bool const test_performance_;
bool const multiword_only_;
};
// Adds 2 tests to the verifier: one full test with 4 stripes,
// and one reduced test (only Blockword and Multiword) for 3 stripes.
template<typename Crc, typename TableEntry, typename Word>
void CreateTest(size_t degree,
uint64 poly_hi,
uint64 poly_lo,
const char *title,
bool test_performance,
CrcVerifier *v) {
char name[128];
bool canonical = true;
for (;;) {
sprintf(name, "CRC-%d-%s-4-%s", static_cast<int>(degree),
title, (canonical ? "canonical" : "raw"));
v->add(new CrcVerifierFactory<Crc, TableEntry, Word, 4>(canonical,
degree,
poly_hi,
poly_lo,
name,
test_performance,
false));
if (degree == 128 && HAVE_AMD64) {
sprintf(name, "CRC-%d-%s-6-%s", static_cast<int>(degree),
title, (canonical ? "canonical" : "raw"));
v->add(new CrcVerifierFactory<Crc, TableEntry, Word, 6>(canonical,
degree,
poly_hi,
poly_lo,
name,
test_performance,
true));
}
sprintf(name, "CRC-%d-%s-3-%s", static_cast<int>(degree),
title, (canonical ? "canonical" : "raw"));
v->add(new CrcVerifierFactory<Crc, TableEntry, Word, 3>(canonical,
degree,
poly_hi,
poly_lo,
name,
test_performance,
true));
if (!canonical) {
break;
}
canonical = false;
test_performance = false;
}
}
#if defined(_INTEL_COMPILER)
#pragma warning(pop)
#endif // defined(_INTEL_COMPILER)
} // namespace crcutil
#endif // CRCUTIL_UNITTEST_H_
Reference in New Issue View Git Blame Copy Permalink