/*
- * Copyright 2012 Facebook, Inc.
+ * Copyright 2017 Facebook, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
// @author Tudor Bosman (tudorb@fb.com)
-#include <gflags/gflags.h>
-#include "folly/Bits.h"
-#include "folly/Benchmark.h"
-#include <gtest/gtest.h>
+#include <folly/Bits.h>
+
+#include <random>
+
+#include <folly/portability/GTest.h>
using namespace folly;
+// Test constexpr-ness.
+#if !defined(__clang__) && !defined(_MSC_VER)
+static_assert(findFirstSet(2u) == 2, "findFirstSet");
+static_assert(findLastSet(2u) == 2, "findLastSet");
+static_assert(nextPowTwo(2u) == 2, "nextPowTwo");
+#endif
+
+#ifndef __clang__
+static_assert(isPowTwo(2u), "isPowTwo");
+#endif
+
namespace {
template <class INT>
}
}
-template <class INT>
-unsigned int findLastSetPortable(INT x) {
- return detail::findLastSetPortable(
- static_cast<typename std::make_unsigned<INT>::type>(x));
-}
-
template <class INT>
void testFLS() {
- typedef typename std::make_unsigned<INT>::type UINT;
+ typedef typename std::make_unsigned<INT>::type UINT_T;
EXPECT_EQ(0, findLastSet(static_cast<INT>(0)));
- size_t bits = std::numeric_limits<UINT>::digits;
+ size_t bits = std::numeric_limits<UINT_T>::digits;
for (size_t i = 0; i < bits; i++) {
- INT v1 = static_cast<UINT>(1) << i;
+ INT v1 = static_cast<UINT_T>(1) << i;
EXPECT_EQ(i + 1, findLastSet(v1));
- EXPECT_EQ(i + 1, findLastSetPortable(v1));
- INT v2 = (static_cast<UINT>(1) << i) - 1;
+ INT v2 = (static_cast<UINT_T>(1) << i) - 1;
EXPECT_EQ(i, findLastSet(v2));
- EXPECT_EQ(i, findLastSetPortable(v2));
}
}
-} // namespace
+} // namespace
TEST(Bits, FindFirstSet) {
testFFS<char>();
testFLS<unsigned long long>();
}
-#define testPowTwo(nextPowTwoFunc) { \
- EXPECT_EQ(1, nextPowTwoFunc(0u)); \
- EXPECT_EQ(1, nextPowTwoFunc(1u)); \
- EXPECT_EQ(2, nextPowTwoFunc(2u)); \
- EXPECT_EQ(4, nextPowTwoFunc(3u)); \
- EXPECT_EQ(4, nextPowTwoFunc(4u)); \
- EXPECT_EQ(8, nextPowTwoFunc(5u)); \
- EXPECT_EQ(8, nextPowTwoFunc(6u)); \
- EXPECT_EQ(8, nextPowTwoFunc(7u)); \
- EXPECT_EQ(8, nextPowTwoFunc(8u)); \
- EXPECT_EQ(16, nextPowTwoFunc(9u)); \
- EXPECT_EQ(16, nextPowTwoFunc(13u)); \
- EXPECT_EQ(16, nextPowTwoFunc(16u)); \
- EXPECT_EQ(512, nextPowTwoFunc(510u)); \
- EXPECT_EQ(512, nextPowTwoFunc(511u)); \
- EXPECT_EQ(512, nextPowTwoFunc(512u)); \
- EXPECT_EQ(1024, nextPowTwoFunc(513u)); \
- EXPECT_EQ(1024, nextPowTwoFunc(777u)); \
- EXPECT_EQ(1ul << 31, nextPowTwoFunc((1ul << 31) - 1)); \
- EXPECT_EQ(1ul << 32, nextPowTwoFunc((1ul << 32) - 1)); \
- EXPECT_EQ(1ull << 63, nextPowTwoFunc((1ull << 62) + 1)); \
-}
-
-
-#ifdef __GNUC__
-
TEST(Bits, nextPowTwoClz) {
- testPowTwo(nextPowTwo);
+ EXPECT_EQ(1, nextPowTwo(0u));
+ EXPECT_EQ(1, nextPowTwo(1u));
+ EXPECT_EQ(2, nextPowTwo(2u));
+ EXPECT_EQ(4, nextPowTwo(3u));
+ EXPECT_EQ(4, nextPowTwo(4u));
+ EXPECT_EQ(8, nextPowTwo(5u));
+ EXPECT_EQ(8, nextPowTwo(6u));
+ EXPECT_EQ(8, nextPowTwo(7u));
+ EXPECT_EQ(8, nextPowTwo(8u));
+ EXPECT_EQ(16, nextPowTwo(9u));
+ EXPECT_EQ(16, nextPowTwo(13u));
+ EXPECT_EQ(16, nextPowTwo(16u));
+ EXPECT_EQ(512, nextPowTwo(510u));
+ EXPECT_EQ(512, nextPowTwo(511u));
+ EXPECT_EQ(512, nextPowTwo(512u));
+ EXPECT_EQ(1024, nextPowTwo(513u));
+ EXPECT_EQ(1024, nextPowTwo(777u));
+ EXPECT_EQ(1ul << 31, nextPowTwo((1ul << 31) - 1));
+ EXPECT_EQ(1ull << 32, nextPowTwo((1ull << 32) - 1));
+ EXPECT_EQ(1ull << 63, nextPowTwo((1ull << 62) + 1));
}
-int x; // prevent the loop from getting optimized away
-BENCHMARK(nextPowTwoClz, iters) {
- x = folly::nextPowTwo(iters);
+TEST(Bits, prevPowTwoClz) {
+ EXPECT_EQ(0, prevPowTwo(0u));
+ EXPECT_EQ(1, prevPowTwo(1u));
+ EXPECT_EQ(2, prevPowTwo(2u));
+ EXPECT_EQ(2, prevPowTwo(3u));
+ EXPECT_EQ(4, prevPowTwo(4u));
+ EXPECT_EQ(4, prevPowTwo(5u));
+ EXPECT_EQ(4, prevPowTwo(6u));
+ EXPECT_EQ(4, prevPowTwo(7u));
+ EXPECT_EQ(8, prevPowTwo(8u));
+ EXPECT_EQ(8, prevPowTwo(9u));
+ EXPECT_EQ(8, prevPowTwo(13u));
+ EXPECT_EQ(16, prevPowTwo(16u));
+ EXPECT_EQ(256, prevPowTwo(510u));
+ EXPECT_EQ(256, prevPowTwo(511u));
+ EXPECT_EQ(512, prevPowTwo(512u));
+ EXPECT_EQ(512, prevPowTwo(513u));
+ EXPECT_EQ(512, prevPowTwo(777u));
+ EXPECT_EQ(1ul << 30, prevPowTwo((1ul << 31) - 1));
+ EXPECT_EQ(1ull << 31, prevPowTwo((1ull << 32) - 1));
+ EXPECT_EQ(1ull << 62, prevPowTwo((1ull << 62) + 1));
}
-#endif
-
-TEST(Bits, nextPowTwoPortable) {
- testPowTwo(detail::nextPowTwoPortable);
+TEST(Bits, isPowTwo) {
+ EXPECT_FALSE(isPowTwo(0u));
+ EXPECT_TRUE(isPowTwo(1ul));
+ EXPECT_TRUE(isPowTwo(2ull));
+ EXPECT_FALSE(isPowTwo(3ul));
+ EXPECT_TRUE(isPowTwo(4ul));
+ EXPECT_FALSE(isPowTwo(5ul));
+ EXPECT_TRUE(isPowTwo(8ul));
+ EXPECT_FALSE(isPowTwo(15u));
+ EXPECT_TRUE(isPowTwo(16u));
+ EXPECT_FALSE(isPowTwo(17u));
+ EXPECT_FALSE(isPowTwo(511ul));
+ EXPECT_TRUE(isPowTwo(512ul));
+ EXPECT_FALSE(isPowTwo(513ul));
+ EXPECT_FALSE(isPowTwo((1ul<<31) - 1));
+ EXPECT_TRUE(isPowTwo(1ul<<31));
+ EXPECT_FALSE(isPowTwo((1ul<<31) + 1));
+ EXPECT_FALSE(isPowTwo((1ull<<63) - 1));
+ EXPECT_TRUE(isPowTwo(1ull<<63));
+ EXPECT_FALSE(isPowTwo((1ull<<63) + 1));
}
-BENCHMARK(nextPowTwoPortable, iters) {
- x = detail::nextPowTwoPortable(iters);
+TEST(Bits, popcount) {
+ EXPECT_EQ(0, popcount(0U));
+ EXPECT_EQ(1, popcount(1U));
+ EXPECT_EQ(32, popcount(uint32_t(-1)));
+ EXPECT_EQ(64, popcount(uint64_t(-1)));
}
-BENCHMARK_DRAW_LINE();
-
-int main(int argc, char** argv) {
- testing::InitGoogleTest(&argc, argv);
- google::ParseCommandLineFlags(&argc, &argv, true);
- auto ret = RUN_ALL_TESTS();
- if (!ret && FLAGS_benchmark) {
- folly::runBenchmarks();
- }
- return ret;
+TEST(Bits, Endian_swap_uint) {
+ EXPECT_EQ(uint8_t(0xda), Endian::swap(uint8_t(0xda)));
+ EXPECT_EQ(uint16_t(0x4175), Endian::swap(uint16_t(0x7541)));
+ EXPECT_EQ(uint32_t(0x42efb918), Endian::swap(uint32_t(0x18b9ef42)));
+ EXPECT_EQ(
+ uint64_t(0xa244f5e862c71d8a), Endian::swap(uint64_t(0x8a1dc762e8f544a2)));
}
-/*
-Benchmarks run on dual Xeon X5650's @ 2.67GHz w/hyperthreading enabled
- (12 physical cores, 12 MB cache, 72 GB RAM)
-
-Benchmark Iters Total t t/iter iter/sec
-------------------------------------------------------------------------------
-* nextPowTwoClz 1000000 1.659 ms 1.659 ns 574.8 M
- +66.8% nextPowTwoPortable 1000000 2.767 ms 2.767 ns 344.7 M
-*/
+TEST(Bits, Endian_swap_real) {
+ std::mt19937_64 rng;
+ auto f = std::uniform_real_distribution<float>()(rng);
+ EXPECT_NE(f, Endian::swap(f));
+ EXPECT_EQ(f, Endian::swap(Endian::swap(f)));
+ auto d = std::uniform_real_distribution<double>()(rng);
+ EXPECT_NE(d, Endian::swap(d));
+ EXPECT_EQ(d, Endian::swap(Endian::swap(d)));
+}
projects / folly.git / blobdiff