Add new benchmark options.

Add a bunch of extra options to allow greater flexibility for creating
benchmarks. Add a pattern option that can be used to represent any
one buffer or two buffer possibility. This should fully replace the
functionality of microbench.

Add a single option for one buffer benchmarks and two buffer benchmarks
that represents all of the possible options to run a string benchmark.

Add a string test suite that includes all string benchmarks using the
above option.

Test: New unit tests to cover all the new options, and all pass.
Test: Ran new string test suite with a single bionic iteration.
Change-Id: Idb13ea15e44cec626e9f46672ccd648d7ca72ba6

1 files changed, 189 insertions, 45 deletions

diff --git a/benchmarks/bionic_benchmarks.cpp b/benchmarks/bionic_benchmarks.cpp
index 27829a6b0..d82c739a3 100644
--- a/benchmarks/bionic_benchmarks.cpp
+++ b/benchmarks/bionic_benchmarks.cpp
@@ -27,11 +27,50 @@
 #include <vector>
 
 #include <android-base/file.h>
+#include <android-base/stringprintf.h>
 #include <android-base/strings.h>
 #include <benchmark/benchmark.h>
 #include <tinyxml2.h>
 #include "util.h"
 
+static const std::vector<int> kCommonSizes{
+  8,
+  64,
+  512,
+  1 * KB,
+  8 * KB,
+  16 * KB,
+  32 * KB,
+  64 * KB,
+  128 * KB,
+};
+
+static const std::vector<int> kSmallSizes{
+  // Increment by 1
+  1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+  // Increment by 8
+  24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120, 128, 136, 144,
+  // Increment by 16
+  160, 176, 192, 208, 224, 240, 256,
+};
+
+static const std::vector<int> kMediumSizes{
+  512,
+  1 * KB,
+  8 * KB,
+  16 * KB,
+  32 * KB,
+  64 * KB,
+  128 * KB,
+};
+
+static const std::vector<int> kLargeSizes{
+  256 * KB,
+  512 * KB,
+  1024 * KB,
+  2048 * KB,
+};
+
 std::map<std::string, std::pair<benchmark_func_t, std::string>> g_str_to_func;
 
 std::mutex g_map_lock;
@@ -172,13 +211,85 @@ void LockAndRun(benchmark::State& state, benchmark_func_t func_to_bench, long cp
   reinterpret_cast<void(*) (benchmark::State&)>(func_to_bench)(state);
 }
 
+static constexpr char kOnebufManualStr[] = "AT_ONEBUF_MANUAL_ALIGN_";
+static constexpr char kTwobufManualStr[] = "AT_TWOBUF_MANUAL_ALIGN1_";
+
+static bool ParseOnebufManualStr(std::string& arg, std::vector<int>* values) {
+  // The format of this is:
+  //   AT_ONEBUF_MANUAL_ALIGN_XX_SIZE_YY
+  // Where:
+  //   XX is the alignment
+  //   YY is the size
+  int align;
+  int size;
+  if (sscanf(arg.c_str(), "AT_ONEBUF_MANUAL_ALIGN_%d_SIZE_%d" , &align, &size) != 2) {
+    return false;
+  }
+
+  if (align != 0 && (align & (align - 1)) != 0) {
+    return false;
+  }
+
+  values->push_back(static_cast<int>(size));
+  values->push_back(static_cast<int>(align));
+  return true;
+}
+
+static bool ParseTwobufManualStr(std::string& arg, std::vector<int>* values) {
+  // The format of this is:
+  //   AT_TWOBUF_MANUAL_ALIGN1_XX_ALIGN2_YY_SIZE_ZZ
+  // Where:
+  //   XX is the alignment of the first argument
+  //   YY is the alignment of the second argument
+  //   ZZ is the size
+  int align1;
+  int align2;
+  int size;
+  if (sscanf(arg.c_str(), "AT_TWOBUF_MANUAL_ALIGN1_%d_ALIGN2_%d_SIZE_%d" ,
+             &align1, &align2, &size) != 3) {
+    return false;
+  }
+
+  // Verify the alignments are powers of 2.
+  if ((align1 != 0 && (align1 & (align1 - 1)) != 0)
+      || (align2 != 0 && (align2 & (align2 - 1)) != 0)) {
+    return false;
+  }
+
+  values->push_back(static_cast<int>(size));
+  values->push_back(static_cast<int>(align1));
+  values->push_back(static_cast<int>(align2));
+  return true;
+}
+
 args_vector_t* ResolveArgs(args_vector_t* to_populate, std::string args,
                            std::map<std::string, args_vector_t>& args_shorthand) {
-  // args is either a space-separated list of ints or a macro name.
+  // args is either a space-separated list of ints, a macro name, or
+  // special free form macro.
   // To ease formatting in XML files, args is left and right trimmed.
   if (args_shorthand.count(args)) {
     return &args_shorthand[args];
   }
+  // Check for free form macro.
+  if (android::base::StartsWith(args, kOnebufManualStr)) {
+    std::vector<int> values;
+    if (!ParseOnebufManualStr(args, &values)) {
+      errx(1, "ERROR: Bad format of macro %s, should be AT_ONEBUF_MANUAL_ALIGN_XX_SIZE_YY",
+           args.c_str());
+    }
+    to_populate->push_back(std::move(values));
+    return to_populate;
+  } else if (android::base::StartsWith(args, kTwobufManualStr)) {
+    std::vector<int> values;
+    if (!ParseTwobufManualStr(args, &values)) {
+      errx(1,
+           "ERROR: Bad format of macro %s, should be AT_TWOBUF_MANUAL_ALIGN1_XX_ALIGNE2_YY_SIZE_ZZ",
+           args.c_str());
+    }
+    to_populate->push_back(std::move(values));
+    return to_populate;
+  }
+
   to_populate->push_back(std::vector<int>());
   std::stringstream sstream(args);
   std::string argstr;
@@ -306,27 +417,66 @@ int RegisterXmlBenchmarks(bench_opts_t cmdline_opts,
   return 0;
 }
 
+static void SetArgs(const std::vector<int>& sizes, args_vector_t* args) {
+  for (int size : sizes) {
+    args->push_back({size});
+  }
+}
+
+static void SetArgs(const std::vector<int>& sizes, int align, args_vector_t* args) {
+  for (int size : sizes) {
+    args->push_back({size, align});
+  }
+}
+
+
+static void SetArgs(const std::vector<int>& sizes, int align1, int align2, args_vector_t* args) {
+  for (int size : sizes) {
+    args->push_back({size, align1, align2});
+  }
+}
+
+static args_vector_t GetArgs(const std::vector<int>& sizes) {
+  args_vector_t args;
+  SetArgs(sizes, &args);
+  return args;
+}
+
+static args_vector_t GetArgs(const std::vector<int>& sizes, int align) {
+  args_vector_t args;
+  SetArgs(sizes, align, &args);
+  return args;
+}
+
+static args_vector_t GetArgs(const std::vector<int>& sizes, int align1, int align2) {
+  args_vector_t args;
+  SetArgs(sizes, align1, align2, &args);
+  return args;
+}
+
 std::map<std::string, args_vector_t> GetShorthand() {
+  std::vector<int> all_sizes(kSmallSizes);
+  all_sizes.insert(all_sizes.end(), kMediumSizes.begin(), kMediumSizes.end());
+  all_sizes.insert(all_sizes.end(), kLargeSizes.begin(), kLargeSizes.end());
+
   std::map<std::string, args_vector_t> args_shorthand {
-    {"AT_ALIGNED_TWOBUF", args_vector_t{ {8, 0, 0},
-                                         {64, 0, 0},
-                                         {512, 0, 0},
-                                         {1 * KB, 0, 0},
-                                         {8 * KB, 0, 0},
-                                         {16 * KB, 0, 0},
-                                         {32 * KB, 0, 0},
-                                         {64 * KB, 0, 0} }},
-    {"AT_ALIGNED_ONEBUF", args_vector_t{ {(8), 0},
-                                         {(64), 0},
-                                         {(512), 0},
-                                         {(1*KB), 0},
-                                         {(8*KB), 0},
-                                         {(16*KB), 0},
-                                         {(32*KB), 0},
-                                         {(64*KB), 0}}},
-
-    {"AT_COMMON_SIZES", args_vector_t{ {8}, {64}, {512}, {1*KB}, {8*KB}, {16*KB},
-                                                       {32*KB}, {64*KB}}},
+    {"AT_COMMON_SIZES", GetArgs(kCommonSizes)},
+    {"AT_SMALL_SIZES", GetArgs(kSmallSizes)},
+    {"AT_MEDIUM_SIZES", GetArgs(kMediumSizes)},
+    {"AT_LARGE_SIZES", GetArgs(kLargeSizes)},
+    {"AT_ALL_SIZES", GetArgs(all_sizes)},
+
+    {"AT_ALIGNED_ONEBUF", GetArgs(kCommonSizes, 0)},
+    {"AT_ALIGNED_ONEBUF_SMALL", GetArgs(kSmallSizes, 0)},
+    {"AT_ALIGNED_ONEBUF_MEDIUM", GetArgs(kMediumSizes, 0)},
+    {"AT_ALIGNED_ONEBUF_LARGE", GetArgs(kLargeSizes, 0)},
+    {"AT_ALIGNED_ONEBUF_ALL", GetArgs(all_sizes, 0)},
+
+    {"AT_ALIGNED_TWOBUF", GetArgs(kCommonSizes, 0, 0)},
+    {"AT_ALIGNED_TWOBUF_SMALL", GetArgs(kSmallSizes, 0, 0)},
+    {"AT_ALIGNED_TWOBUF_MEDIUM", GetArgs(kMediumSizes, 0, 0)},
+    {"AT_ALIGNED_TWOBUF_LARGE", GetArgs(kLargeSizes, 0, 0)},
+    {"AT_ALIGNED_TWOBUF_ALL", GetArgs(all_sizes, 0, 0)},
 
     // Do not exceed 512. that is about the largest number of properties
     // that can be created with the current property area size.
@@ -334,32 +484,26 @@ std::map<std::string, args_vector_t> GetShorthand() {
 
     {"MATH_COMMON", args_vector_t{ {0}, {1}, {2}, {3} }}
   };
-  for (int i = 1; i < 15; i++) {
-    int align = pow(2, i);
-    std::stringstream sstream;
-    sstream << "AT_" << align << "_ALIGN_TWOBUF";
-    args_shorthand.emplace(sstream.str(),
-                           args_vector_t{ {8, align, align},
-                                          {64, align, align},
-                                          {512, align, align},
-                                          {1 * KB, align, align},
-                                          {8 * KB, align, align},
-                                          {16 * KB, align, align},
-                                          {32 * KB, align, align},
-                                          {64 * KB, align, align} });
-    sstream.str("");
-    sstream << "AT_" << align << "_ALIGN_ONEBUF";
-    args_shorthand.emplace(sstream.str(),
-                            args_vector_t{ {(8), align},
-                                           {(64), align},
-                                           {(512), align},
-                                           {(1*KB), align},
-                                           {(8*KB), align},
-                                           {(16*KB), align},
-                                           {(32*KB), align},
-                                           {(64*KB), align} });
-    sstream.str("");
+
+  args_vector_t args_onebuf;
+  args_vector_t args_twobuf;
+  for (int size : all_sizes) {
+    args_onebuf.push_back({size, 0});
+    args_twobuf.push_back({size, 0, 0});
+    // Skip alignments on zero sizes.
+    if (size == 0) {
+      continue;
+    }
+    for (int align1 = 1; align1 <= 32; align1 <<= 1) {
+      args_onebuf.push_back({size, align1});
+      for (int align2 = 1; align2 <= 32; align2 <<= 1) {
+        args_twobuf.push_back({size, align1, align2});
+      }
+    }
   }
+  args_shorthand.emplace("AT_MANY_ALIGNED_ONEBUF", args_onebuf);
+  args_shorthand.emplace("AT_MANY_ALIGNED_TWOBUF", args_twobuf);
+
   return args_shorthand;
 }