Speed-up StringPiece::find_first_of()

author Mike Curtiss <mcurtiss@fb.com>

Fri, 23 Nov 2012 21:44:46 +0000 (13:44 -0800)

committer Jordan DeLong <jdelong@fb.com>

Sat, 19 Jan 2013 00:37:53 +0000 (16:37 -0800)
author Mike Curtiss <mcurtiss@fb.com>
Fri, 23 Nov 2012 21:44:46 +0000 (13:44 -0800)
committer Jordan DeLong <jdelong@fb.com>
Sat, 19 Jan 2013 00:37:53 +0000 (16:37 -0800)
diff --git a/folly/Range.cpp b/folly/Range.cpp

index 45ffd39d445d64ca96c815ad8fa00c4b9f1c24b7..4aee27de6bdbb7e2dc9c78c0de8fda0068f1cca8 100644 (file)
--- a/folly/Range.cpp
+++ b/folly/Range.cpp
@@ -1,5 +1,5 @@
  /*
- * Copyright 2012 Facebook, Inc.
+ * Copyright 2013 Facebook, Inc.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
@@ -21,6 +21,9 @@
  
  #include "folly/Range.h"
  
+#include "folly/CpuId.h"
+#include "folly/Likely.h"
+
  namespace folly {
  
  /**
@@ -34,4 +37,156 @@ std::ostream& operator<<(std::ostream& os, const StringPiece& piece) {
    return os;
  }
  
-} // namespace folly
+namespace detail {
+size_t qfind_first_byte_of_memchr(const StringPiece& haystack,
+                                  const StringPiece& needles) {
+  size_t best = haystack.size();
+  for (char needle: needles) {
+    const void* ptr = memchr(haystack.data(), needle, best);
+    if (ptr) {
+      auto found = static_cast<const char*>(ptr) - haystack.data();
+      best = std::min<size_t>(best, found);
+    }
+  }
+  if (best == haystack.size()) {
+    return StringPiece::npos;
+  }
+  return best;
+}
+}  // namespace detail
+
+namespace {
+// build sse4.2-optimized version even if -msse4.2 is not passed to GCC
+size_t qfind_first_byte_of_needles16(const StringPiece& haystack,
+                                     const StringPiece& needles)
+  __attribute__ ((__target__("sse4.2")));
+
+// helper method for case where needles.size() <= 16
+size_t qfind_first_byte_of_needles16(const StringPiece& haystack,
+                                     const StringPiece& needles) {
+  DCHECK_LE(needles.size(), 16);
+  if (needles.size() <= 2 && haystack.size() >= 256) {
+    // benchmarking shows that memchr beats out SSE for small needle-sets
+    // with large haystacks.
+    // TODO(mcurtiss): could this be because of unaligned SSE loads?
+    return detail::qfind_first_byte_of_memchr(haystack, needles);
+  }
+  auto arr2 = __builtin_ia32_loaddqu(needles.data());
+  for (size_t i = 0; i < haystack.size(); i+= 16) {
+    auto arr1 = __builtin_ia32_loaddqu(haystack.data() + i);
+    auto index = __builtin_ia32_pcmpestri128(arr2, needles.size(),
+                                             arr1, haystack.size() - i, 0);
+    if (index < 16) {
+      return i + index;
+    }
+  }
+  return StringPiece::npos;
+}
+
+size_t qfind_first_byte_of_sse42(const StringPiece& haystack,
+                                 const StringPiece& needles)
+  __attribute__ ((__target__("sse4.2")));
+
+size_t qfind_first_byte_of_sse42(const StringPiece& haystack,
+                                 const StringPiece& needles) {
+  if (UNLIKELY(needles.empty() || haystack.empty())) {
+    return StringPiece::npos;
+  } else if (needles.size() <= 16) {
+    // we can save some unnecessary load instructions by optimizing for
+    // the common case of needles.size() <= 16
+    return qfind_first_byte_of_needles16(haystack, needles);
+  }
+
+  size_t index = haystack.size();
+  for (size_t i = 0; i < haystack.size(); i += 16) {
+    size_t b = 16;
+    auto arr1 = __builtin_ia32_loaddqu(haystack.data() + i);
+    for (size_t j = 0; j < needles.size(); j += 16) {
+      auto arr2 = __builtin_ia32_loaddqu(needles.data() + j);
+      auto index = __builtin_ia32_pcmpestri128(arr2, needles.size() - j,
+                                               arr1, haystack.size() - i, 0);
+      b = std::min<size_t>(index, b);
+    }
+    if (b < 16) {
+      return i + b;
+    }
+  };
+  return StringPiece::npos;
+}
+
+typedef decltype(qfind_first_byte_of_sse42) Type_qfind_first_byte_of;
+
+// Aho, Hopcroft, and Ullman refer to this trick in "The Design and Analysis
+// of Computer Algorithms" (1974), but the best description is here:
+// http://research.swtch.com/sparse
+class FastByteSet {
+ public:
+  FastByteSet() : size_(0) { }  // no init of arrays required!
+
+  inline void add(uint8_t i) {
+    if (!contains(i)) {
+      dense_[size_] = i;
+      sparse_[i] = size_;
+      size_++;
+    }
+  }
+  inline bool contains(uint8_t i) const {
+    DCHECK_LE(size_, 256);
+    return sparse_[i] < size_ && dense_[sparse_[i]] == i;
+  }
+
+ private:
+  uint16_t size_;  // can't use uint8_t because it would overflow if all
+                   // possible values were inserted.
+  uint8_t sparse_[256];
+  uint8_t dense_[256];
+};
+}  // namespace
+
+namespace detail {
+size_t qfind_first_byte_of_byteset(const StringPiece& haystack,
+                                   const StringPiece& needles) {
+  FastByteSet s;
+  for (auto needle: needles) {
+    s.add(needle);
+  }
+  for (size_t index = 0; index < haystack.size(); ++index) {
+    if (s.contains(haystack[index])) {
+      return index;
+    }
+  }
+  return StringPiece::npos;
+}
+
+size_t qfind_first_byte_of_nosse(const StringPiece& haystack,
+                                 const StringPiece& needles) {
+  if (UNLIKELY(needles.empty() || haystack.empty())) {
+    return StringPiece::npos;
+  }
+  // The thresholds below were empirically determined by benchmarking.
+  // This is not an exact science since it depends on the CPU, the size of
+  // needles, and the size of haystack.
+  if (haystack.size() == 1 ||
+      (haystack.size() < 4 && needles.size() <= 16)) {
+    return qfind_first_of(haystack, needles, asciiCaseSensitive);
+  } else if ((needles.size() >= 4 && haystack.size() <= 10) ||
+             (needles.size() >= 16 && haystack.size() <= 64) ||
+             needles.size() >= 32) {
+    return qfind_first_byte_of_byteset(haystack, needles);
+  }
+
+  return qfind_first_byte_of_memchr(haystack, needles);
+}
+
+// This function is called on startup to resolve folly::qfind_first_byte_of
+extern "C" Type_qfind_first_byte_of* qfind_first_byte_of_ifunc() {
+  return folly::CpuId().sse42() ? qfind_first_byte_of_sse42 :
+    qfind_first_byte_of_nosse;
+}
+
+size_t qfind_first_byte_of(const StringPiece& haystack,
+                           const StringPiece& needles)
+  __attribute__((ifunc("qfind_first_byte_of_ifunc")));
+
+}  // namespace detail
+}  // namespace folly
diff --git a/folly/Range.h b/folly/Range.h

index e214bee91c86f57197c240bd8bc19c1b52bb0c66..196e8d3dc7d29285f4b7bf31a54eeb7e326d17c5 100644 (file)
--- a/folly/Range.h
+++ b/folly/Range.h
@@ -1,5 +1,5 @@
  /*
- * Copyright 2012 Facebook, Inc.
+ * Copyright 2013 Facebook, Inc.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
@@ -592,12 +592,17 @@ size_t qfind(const Range<T>& haystack,
    return std::string::npos;
  }
  
+namespace detail {
+size_t qfind_first_byte_of(const StringPiece& haystack,
+                           const StringPiece& needles);
+} // namespace detail
+
  template <class T, class Comp>
  size_t qfind_first_of(const Range<T> & haystack,
-                      const Range<T> & needle,
+                      const Range<T> & needles,
                        Comp eq) {
    auto ret = std::find_first_of(haystack.begin(), haystack.end(),
-                                needle.begin(), needle.end(),
+                                needles.begin(), needles.end(),
                                  eq);
    return ret == haystack.end() ? std::string::npos : ret - haystack.begin();
  }
@@ -649,10 +654,24 @@ inline size_t qfind(const Range<const unsigned char*>& haystack,
  
  template <class T>
  size_t qfind_first_of(const Range<T>& haystack,
-                      const Range<T>& needle) {
-  return qfind_first_of(haystack, needle, asciiCaseSensitive);
+                      const Range<T>& needles) {
+  return qfind_first_of(haystack, needles, asciiCaseSensitive);
+}
+
+// specialization for StringPiece
+template <>
+inline size_t qfind_first_of(const Range<const char*>& haystack,
+                             const Range<const char*>& needles) {
+  return detail::qfind_first_byte_of(haystack, needles);
  }
  
+// specialization for ByteRange
+template <>
+inline size_t qfind_first_of(const Range<const unsigned char*>& haystack,
+                             const Range<const unsigned char*>& needles) {
+  return detail::qfind_first_byte_of(StringPiece(haystack),
+                                     StringPiece(needles));
+}
  }  // !namespace folly
  
  FOLLY_ASSUME_FBVECTOR_COMPATIBLE_1(folly::Range);
diff --git a/folly/test/RangeFindBenchmark.cpp b/folly/test/RangeFindBenchmark.cpp

index 654e00b2c649f97eb705cd81770e6cb7c0e0748a..031c67b8e4bbcc41a496ca5605162b5fe2e9b5f2 100644 (file)
--- a/folly/test/RangeFindBenchmark.cpp
+++ b/folly/test/RangeFindBenchmark.cpp
@@ -19,8 +19,21 @@
  #include "folly/Foreach.h"
  #include <algorithm>
  #include <iostream>
+#include <random>
  #include <string>
  
+namespace folly { namespace detail {
+// declaration of functions in Range.cpp
+size_t qfind_first_byte_of_memchr(const StringPiece& haystack,
+                                  const StringPiece& needles);
+
+size_t qfind_first_byte_of_byteset(const StringPiece& haystack,
+                                   const StringPiece& needles);
+
+size_t qfind_first_byte_of_nosse(const StringPiece& haystack,
+                                 const StringPiece& needles);
+}}
+
  using namespace folly;
  using namespace std;
  
@@ -36,6 +49,43 @@ void initStr(int len) {
    str.append(1, 'b');
  }
  
+std::mt19937 rnd;
+string ffoTestString;
+const size_t ffoDelimSize = 128;
+vector<string> ffoDelim;
+
+string generateString(int len) {
+  std::uniform_int_distribution<uint32_t> validChar(1, 255);  // no null-char
+  string ret;
+  while (len--) {
+    ret.push_back(validChar(rnd));
+  }
+  return ret;
+}
+
+void initDelims(int len) {
+  ffoDelim.clear();
+
+  string s(len - 1, '\0');  // find_first_of won't finish until last char
+  s.push_back('a');
+  ffoTestString = s;
+
+  for (int i = 0; i < ffoDelimSize; ++i) {
+    // most delimiter sets are pretty small, but occasionally there could
+    // be a big one.
+    auto n = rnd() % 8 + 1;
+    if (n == 8) {
+      n = 32;
+    }
+    auto s = generateString(n);
+    if (rnd() % 2) {
+      // ~half of tests will find a hit
+      s[rnd() % s.size()] = 'a';  // yes, this could mean 'a' is a duplicate
+    }
+    ffoDelim.push_back(s);
+  }
+}
+
  }  // anonymous namespace
  
  BENCHMARK(FindSingleCharMemchr, n) {
@@ -60,17 +110,198 @@ BENCHMARK_RELATIVE(FindSingleCharRange, n) {
  
  BENCHMARK_DRAW_LINE();
  
-BENCHMARK(FindFirstOfRange, n) {
+// it's useful to compare our custom implementations vs. the standard library
+inline size_t qfind_first_byte_of_std(const StringPiece& haystack,
+                                      const StringPiece& needles) {
+  return qfind_first_of(haystack, needles, asciiCaseSensitive);
+}
+
+template <class Func>
+void findFirstOfRange(StringPiece needles, Func func, size_t n) {
    StringPiece haystack(str);
-  folly::StringPiece needles("bc");
-  DCHECK_EQ(haystack.size() - 1, haystack.find_first_of(needles)); // it works!
    FOR_EACH_RANGE (i, 0, n) {
-    doNotOptimizeAway(haystack.find_first_of(needles));
+    doNotOptimizeAway(func(haystack, needles));
      char x = haystack[0];
      doNotOptimizeAway(&x);
    }
  }
  
+const string delims2 = "bc";
+
+BENCHMARK(FindFirstOf2NeedlesBase, n) {
+  findFirstOfRange(delims2, detail::qfind_first_byte_of, n);
+}
+
+BENCHMARK_RELATIVE(FindFirstOf2NeedlesNoSSE, n) {
+  findFirstOfRange(delims2, detail::qfind_first_byte_of_nosse, n);
+}
+
+BENCHMARK_RELATIVE(FindFirstOf2NeedlesStd, n) {
+  findFirstOfRange(delims2, qfind_first_byte_of_std, n);
+}
+
+BENCHMARK_RELATIVE(FindFirstOf2NeedlesMemchr, n) {
+  findFirstOfRange(delims2, detail::qfind_first_byte_of_memchr, n);
+}
+
+BENCHMARK_RELATIVE(FindFirstOf2NeedlesByteSet, n) {
+  findFirstOfRange(delims2, detail::qfind_first_byte_of_byteset, n);
+}
+
+BENCHMARK_DRAW_LINE();
+
+const string delims4 = "bcde";
+
+BENCHMARK(FindFirstOf4NeedlesBase, n) {
+  findFirstOfRange(delims4, detail::qfind_first_byte_of, n);
+}
+
+BENCHMARK_RELATIVE(FindFirstOf4NeedlesNoSSE, n) {
+  findFirstOfRange(delims4, detail::qfind_first_byte_of_nosse, n);
+}
+
+BENCHMARK_RELATIVE(FindFirstOf4NeedlesStd, n) {
+  findFirstOfRange(delims4, qfind_first_byte_of_std, n);
+}
+
+BENCHMARK_RELATIVE(FindFirstOf4NeedlesMemchr, n) {
+  findFirstOfRange(delims4, detail::qfind_first_byte_of_memchr, n);
+}
+
+BENCHMARK_RELATIVE(FindFirstOf4NeedlesByteSet, n) {
+  findFirstOfRange(delims4, detail::qfind_first_byte_of_byteset, n);
+}
+
+BENCHMARK_DRAW_LINE();
+
+const string delims8 = "0123456b";
+
+BENCHMARK(FindFirstOf8NeedlesBase, n) {
+  findFirstOfRange(delims8, detail::qfind_first_byte_of, n);
+}
+
+BENCHMARK_RELATIVE(FindFirstOf8NeedlesNoSSE, n) {
+  findFirstOfRange(delims8, detail::qfind_first_byte_of_nosse, n);
+}
+
+BENCHMARK_RELATIVE(FindFirstOf8NeedlesStd, n) {
+  findFirstOfRange(delims8, qfind_first_byte_of_std, n);
+}
+
+BENCHMARK_RELATIVE(FindFirstOf8NeedlesMemchr, n) {
+  findFirstOfRange(delims8, detail::qfind_first_byte_of_memchr, n);
+}
+
+BENCHMARK_RELATIVE(FindFirstOf8NeedlesByteSet, n) {
+  findFirstOfRange(delims8, detail::qfind_first_byte_of_byteset, n);
+}
+
+BENCHMARK_DRAW_LINE();
+
+const string delims16 = "0123456789bcdefg";
+
+BENCHMARK(FindFirstOf16NeedlesBase, n) {
+  findFirstOfRange(delims16, detail::qfind_first_byte_of, n);
+}
+
+BENCHMARK_RELATIVE(FindFirstOf16NeedlesNoSSE, n) {
+  findFirstOfRange(delims16, detail::qfind_first_byte_of_nosse, n);
+}
+
+BENCHMARK_RELATIVE(FindFirstOf16NeedlesStd, n) {
+  findFirstOfRange(delims16, qfind_first_byte_of_std, n);
+}
+
+BENCHMARK_RELATIVE(FindFirstOf16NeedlesMemchr, n) {
+  findFirstOfRange(delims16, detail::qfind_first_byte_of_memchr, n);
+}
+
+BENCHMARK_RELATIVE(FindFirstOf16NeedlesByteSet, n) {
+  findFirstOfRange(delims16, detail::qfind_first_byte_of_byteset, n);
+}
+
+BENCHMARK_DRAW_LINE();
+
+const string delims32 = "!bcdefghijklmnopqrstuvwxyz_012345";
+
+BENCHMARK(FindFirstOf32NeedlesBase, n) {
+  findFirstOfRange(delims32, detail::qfind_first_byte_of, n);
+}
+
+BENCHMARK_RELATIVE(FindFirstOf32NeedlesNoSSE, n) {
+  findFirstOfRange(delims32, detail::qfind_first_byte_of_nosse, n);
+}
+
+BENCHMARK_RELATIVE(FindFirstOf32NeedlesStd, n) {
+  findFirstOfRange(delims32, qfind_first_byte_of_std, n);
+}
+
+BENCHMARK_RELATIVE(FindFirstOf32NeedlesMemchr, n) {
+  findFirstOfRange(delims32, detail::qfind_first_byte_of_memchr, n);
+}
+
+BENCHMARK_RELATIVE(FindFirstOf32NeedlesByteSet, n) {
+  findFirstOfRange(delims32, detail::qfind_first_byte_of_byteset, n);
+}
+
+BENCHMARK_DRAW_LINE();
+
+const string delims64 = "!bcdefghijklmnopqrstuvwxyz_"
+                        "ABCDEFGHIJKLMNOPQRSTUVWXYZ-0123456789$";
+
+BENCHMARK(FindFirstOf64NeedlesBase, n) {
+  findFirstOfRange(delims64, detail::qfind_first_byte_of, n);
+}
+
+BENCHMARK_RELATIVE(FindFirstOf64NeedlesNoSSE, n) {
+  findFirstOfRange(delims64, detail::qfind_first_byte_of_nosse, n);
+}
+
+BENCHMARK_RELATIVE(FindFirstOf64NeedlesStd, n) {
+  findFirstOfRange(delims64, qfind_first_byte_of_std, n);
+}
+
+BENCHMARK_RELATIVE(FindFirstOf64NeedlesMemchr, n) {
+  findFirstOfRange(delims64, detail::qfind_first_byte_of_memchr, n);
+}
+
+BENCHMARK_RELATIVE(FindFirstOf64NeedlesByteSet, n) {
+  findFirstOfRange(delims64, detail::qfind_first_byte_of_byteset, n);
+}
+
+BENCHMARK_DRAW_LINE();
+
+template <class Func>
+void findFirstOfRandom(Func func, size_t iters) {
+  for (int i = 0; i < iters; ++i) {
+    auto test = i % ffoDelim.size();
+    auto p = func(ffoTestString, ffoDelim[test]);
+    doNotOptimizeAway(p);
+  }
+}
+
+BENCHMARK(FindFirstOfRandomBase, n) {
+  findFirstOfRandom(detail::qfind_first_byte_of, n);
+}
+
+BENCHMARK_RELATIVE(FindFirstOfRandomNoSSE, n) {
+  findFirstOfRandom(detail::qfind_first_byte_of_nosse, n);
+}
+
+BENCHMARK_RELATIVE(FindFirstOfRandomStd, n) {
+  findFirstOfRandom(qfind_first_byte_of_std, n);
+}
+
+BENCHMARK_RELATIVE(FindFirstOfRandomMemchr, n) {
+  findFirstOfRandom(detail::qfind_first_byte_of_memchr, n);
+}
+
+BENCHMARK_RELATIVE(FindFirstOfRandomByteSet, n) {
+  findFirstOfRandom(detail::qfind_first_byte_of_byteset, n);
+}
+
+BENCHMARK_DRAW_LINE();
+
  BENCHMARK(FindFirstOfOffsetRange, n) {
    StringPiece haystack(str);
    folly::StringPiece needles("bc");
@@ -83,11 +314,14 @@ BENCHMARK(FindFirstOfOffsetRange, n) {
    }
  }
  
+BENCHMARK_DRAW_LINE();
+
  int main(int argc, char** argv) {
    google::ParseCommandLineFlags(&argc, &argv, true);
  
-  for (int len : {1, 10, 256, 10*1024, 10*1024*1024}) {
+  for (int len : {1, 8, 10, 16, 32, 64, 128, 256, 10*1024, 1024*1024}) {
      initStr(len);
+    initDelims(len);
      runBenchmarks();
    }
    return 0;
diff --git a/folly/test/RangeTest.cpp b/folly/test/RangeTest.cpp

index e1b055ef1bb7c4c6d6bb7e73fd1e2664e1618ae3..cb8aec8a1cf46d3671109318132156b5929d6fce 100644 (file)
--- a/folly/test/RangeTest.cpp
+++ b/folly/test/RangeTest.cpp
@@ -1,5 +1,5 @@
  /*
- * Copyright 2012 Facebook, Inc.
+ * Copyright 2013 Facebook, Inc.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
@@ -18,10 +18,24 @@
  // @author Kristina Holst (kholst@fb.com)
  // @author Andrei Alexandrescu (andrei.alexandrescu@fb.com)
  
+#include <limits>
+#include <string>
  #include <boost/range/concepts.hpp>
  #include <gtest/gtest.h>
  #include "folly/Range.h"
  
+namespace folly { namespace detail {
+// declaration of functions in Range.cpp
+size_t qfind_first_byte_of_memchr(const StringPiece& haystack,
+                                  const StringPiece& needles);
+
+size_t qfind_first_byte_of_byteset(const StringPiece& haystack,
+                                   const StringPiece& needles);
+
+size_t qfind_first_byte_of_nosse(const StringPiece& haystack,
+                                 const StringPiece& needles);
+}}
+
  using namespace folly;
  using namespace std;
  
@@ -199,4 +213,128 @@ TEST(StringPiece, ToByteRange) {
              static_cast<const void*>(b.begin()));
    EXPECT_EQ(static_cast<const void*>(a.end()),
              static_cast<const void*>(b.end()));
+
+  // and convert back again
+  StringPiece c(b);
+  EXPECT_EQ(a.begin(), c.begin());
+  EXPECT_EQ(a.end(), c.end());
+}
+
+template <typename NeedleFinder>
+class NeedleFinderTest : public ::testing::Test {
+ public:
+  static size_t find_first_byte_of(StringPiece haystack, StringPiece needles) {
+    return NeedleFinder::find_first_byte_of(haystack, needles);
+  }
+};
+
+struct SseNeedleFinder {
+  static size_t find_first_byte_of(StringPiece haystack, StringPiece needles) {
+    // This will only use the SSE version if it is supported on this CPU
+    // (selected using ifunc).
+    return detail::qfind_first_byte_of(haystack, needles);
+  }
+};
+
+struct NoSseNeedleFinder {
+  static size_t find_first_byte_of(StringPiece haystack, StringPiece needles) {
+    return detail::qfind_first_byte_of_nosse(haystack, needles);
+  }
+};
+
+struct MemchrNeedleFinder {
+  static size_t find_first_byte_of(StringPiece haystack, StringPiece needles) {
+    return detail::qfind_first_byte_of_memchr(haystack, needles);
+  }
+};
+
+struct ByteSetNeedleFinder {
+  static size_t find_first_byte_of(StringPiece haystack, StringPiece needles) {
+    return detail::qfind_first_byte_of_byteset(haystack, needles);
+  }
+};
+
+typedef ::testing::Types<SseNeedleFinder, NoSseNeedleFinder, MemchrNeedleFinder,
+                         ByteSetNeedleFinder> NeedleFinders;
+TYPED_TEST_CASE(NeedleFinderTest, NeedleFinders);
+
+TYPED_TEST(NeedleFinderTest, Null) {
+  { // null characters in the string
+    string s(10, char(0));
+    s[5] = 'b';
+    string delims("abc");
+    EXPECT_EQ(5, this->find_first_byte_of(s, delims));
+  }
+  { // null characters in delim
+    string s("abc");
+    string delims(10, char(0));
+    delims[3] = 'c';
+    delims[7] = 'b';
+    EXPECT_EQ(1, this->find_first_byte_of(s, delims));
+  }
+  { // range not terminated by null character
+    string buf = "abcdefghijklmnopqrstuvwxyz";
+    StringPiece s(buf.data() + 5, 3);
+    StringPiece delims("z");
+    EXPECT_EQ(string::npos, this->find_first_byte_of(s, delims));
+  }
+}
+
+TYPED_TEST(NeedleFinderTest, DelimDuplicates) {
+  string delims(1000, 'b');
+  EXPECT_EQ(1, this->find_first_byte_of("abc", delims));
+  EXPECT_EQ(string::npos, this->find_first_byte_of("ac", delims));
+}
+
+TYPED_TEST(NeedleFinderTest, Empty) {
+  string a = "abc";
+  string b = "";
+  EXPECT_EQ(string::npos, this->find_first_byte_of(a, b));
+  EXPECT_EQ(string::npos, this->find_first_byte_of(b, a));
+  EXPECT_EQ(string::npos, this->find_first_byte_of(b, b));
+}
+
+TYPED_TEST(NeedleFinderTest, Unaligned) {
+  // works correctly even if input buffers are not 16-byte aligned
+  string s = "0123456789ABCDEFGH";
+  for (int i = 0; i < s.size(); ++i) {
+    StringPiece a(s.c_str() + i);
+    for (int j = 0; j < s.size(); ++j) {
+      StringPiece b(s.c_str() + j);
+      EXPECT_EQ((i > j) ? 0 : j - i, this->find_first_byte_of(a, b));
+    }
+  }
+}
+
+// for some algorithms (specifically those that create a set of needles),
+// we check for the edge-case of _all_ possible needles being sought.
+TYPED_TEST(NeedleFinderTest, Needles256) {
+  string needles;
+  const auto minValue = std::numeric_limits<StringPiece::value_type>::min();
+  const auto maxValue = std::numeric_limits<StringPiece::value_type>::max();
+  // make the size ~big to avoid any edge-case branches for tiny haystacks
+  const int haystackSize = 50;
+  for (int i = minValue; i <= maxValue; i++) {  // <=
+    needles.push_back(i);
+  }
+  EXPECT_EQ(StringPiece::npos, this->find_first_byte_of("", needles));
+  for (int i = minValue; i <= maxValue; i++) {
+    EXPECT_EQ(0, this->find_first_byte_of(string(haystackSize, i), needles));
+  }
+
+  needles.append("these are redundant characters");
+  EXPECT_EQ(StringPiece::npos, this->find_first_byte_of("", needles));
+  for (int i = minValue; i <= maxValue; i++) {
+    EXPECT_EQ(0, this->find_first_byte_of(string(haystackSize, i), needles));
+  }
+}
+
+TYPED_TEST(NeedleFinderTest, Base) {
+  for (int i = 0; i < 32; ++i) {
+    for (int j = 0; j < 32; ++j) {
+      string s = string(i, 'X') + "abca" + string(i, 'X');
+      string delims = string(j, 'Y') + "a" + string(j, 'Y');
+      EXPECT_EQ(i, this->find_first_byte_of(s, delims));
+    }
+  }
  }
author	Mike Curtiss <mcurtiss@fb.com>
	Fri, 23 Nov 2012 21:44:46 +0000 (13:44 -0800)
committer	Jordan DeLong <jdelong@fb.com>
	Sat, 19 Jan 2013 00:37:53 +0000 (16:37 -0800)
folly/Range.cpp		patch \| blob \| history
folly/Range.h		patch \| blob \| history
folly/test/RangeFindBenchmark.cpp		patch \| blob \| history
folly/test/RangeTest.cpp		patch \| blob \| history