[libc] revamp memory function benchmark

[gchatelet]

Summary

The benchmarking infrastructure can now run in two modes:

• Sweep Mode: which generates a ramp of size values (same as before),
• Distribution Mode: allows the user to select a distribution for the size paramater that is representative from production.

The analysis tool has also been updated to handle both modes.

[courbet]

libc/benchmarks/MemorySizeDistributions.cpp

43

Would it make sense to statically generate the uniform array and just get rid of all the code to handle uniform gen ? We could remove a lot of code with the cost of one additional array here.

[gchatelet]

• Address comments and fix naming style

[courbet]

Only cosmetic comments.

libc/benchmarks/LibcMemoryBenchmark.h

41

Make this a method ?

bool IsSweepMode() {
  return SweepModeMaxSize > 0;
}

libc/benchmarks/LibcMemoryBenchmarkMain.cpp

74

OffsetBytes ?

75

SizeBytes ?

106

did you mean & ?

149

why not const & ?

libc/benchmarks/README.md

98

I think you can drop this.

[gchatelet]

• Address comments

[gchatelet]

rebasing

libc/benchmarks/LibcMemoryBenchmark.h

41

I'm not happy with the redundant information either.
That said the structure is shared between C++ and the external world via JSON and I found it simpler to not replicate the logic everywhere and have a simple boolean attribute.

libc/benchmarks/LibcMemoryBenchmarkMain.cpp

106

Both work but & is clearer. Thx for the suggestion.

149

Good catch!

[gchatelet]

@sivachandra I'll submit this as is. Let me know if you have any concerns and we can amend it in a follow up patch.

[sivachandra]

In D93210#2460196, @gchatelet wrote:

@sivachandra I'll submit this as is. Let me know if you have any concerns and we can amend it in a follow up patch.

Sorry, I am no expert here so I just kept silent while @courbet was steering the review. LGTM.

[gchatelet]

In D93210#2460597, @sivachandra wrote:

In D93210#2460196, @gchatelet wrote:

@sivachandra I'll submit this as is. Let me know if you have any concerns and we can amend it in a follow up patch.

Sorry, I am no expert here so I just kept silent while @courbet was steering the review. LGTM.

Thx 👍 Next time I'll move you as subscriber instead of reviewer.

libc/benchmarks/CMakeLists.txt

 string(REPLACE ";" " " GOOGLE_BENCHMARK_TARGET_FLAGS "${GOOGLE_BENCHMARK_TARGET_FLAGS}")
 
 ExternalProject_Add(google-benchmark
     EXCLUDE_FROM_ALL ON
     PREFIX google-benchmark
     SOURCE_DIR ${LIBC_SOURCE_DIR}/../llvm/utils/benchmark
     INSTALL_DIR ${CMAKE_CURRENT_BINARY_DIR}/google-benchmark
     CMAKE_CACHE_ARGS
+        -DBUILD_SHARED_LIBS:BOOL=OFF
         -DCMAKE_POSITION_INDEPENDENT_CODE:BOOL=ON
         -DCMAKE_C_COMPILER:STRING=${CMAKE_C_COMPILER}
         -DCMAKE_CXX_COMPILER:STRING=${CMAKE_CXX_COMPILER}
         -DCMAKE_CXX_FLAGS:STRING=${GOOGLE_BENCHMARK_TARGET_FLAGS}
         -DCMAKE_CXX_STANDARD:STRING=14
         -DCMAKE_BUILD_TYPE:STRING=RELEASE
         -DCMAKE_INSTALL_PREFIX:PATH=<INSTALL_DIR>
         -DBENCHMARK_ENABLE_TESTING:BOOL=OFF)

 add_library(libc-memory-benchmark
     STATIC
     EXCLUDE_FROM_ALL
     LibcMemoryBenchmark.cpp
     LibcMemoryBenchmark.h
     MemorySizeDistributions.cpp
     MemorySizeDistributions.h
 )
-target_link_libraries(libc-memory-benchmark PUBLIC libc-benchmark)
+target_link_libraries(libc-memory-benchmark
+    PUBLIC
+    libc-benchmark
+)
 fix_rtti(libc-memory-benchmark)
 
 add_libc_benchmark_unittest(libc-memory-benchmark-test
     SRCS LibcMemoryBenchmarkTest.cpp
     DEPENDS libc-memory-benchmark
 )
 
 # json
 add_library(json
     STATIC
     EXCLUDE_FROM_ALL
     JSON.cpp
     JSON.h
 )
 target_link_libraries(json PUBLIC libc-memory-benchmark)
 fix_rtti(json)
 
 add_libc_benchmark_unittest(json-test
     SRCS JSONTest.cpp
     DEPENDS json
 )
 
 #==============================================================================
-# Benchmark tests configuration
+# Benchmarking tool
 #==============================================================================
 
-function(add_libc_benchmark_analysis conf_target run_target)
-    set(png_file "/tmp/last-${conf_target}.png")
-    set(render_target render-${conf_target})
-    add_custom_target(${render_target}
-        COMMAND python3 render.py3 ${json_file} --headless --output=${png_file}
-        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-        COMMENT "render ${libc_target} to ${png_file}"
-    )
-    add_dependencies(${render_target} ${run_target})
-
-    set(display_target display-${conf_target})
-    add_custom_target(${display_target}
-        COMMAND python3 render.py3 ${json_file}
-        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-        COMMENT "display ${libc_target}"
-    )
-    add_dependencies(${display_target} ${run_target})
-endfunction()
-
-function(add_libc_benchmark_configuration target configuration)
-    set(conf_target ${target}-${configuration})
-    set(json_file "/tmp/last-${conf_target}.json")
-    set(run_target run-${conf_target})
-    add_custom_target(${run_target}
-        COMMAND ${libc_target} --conf=configuration_${configuration}.json -o ${json_file}
-        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-    )
-    add_libc_benchmark_analysis(${conf_target} ${run_target})
-endfunction()
-
-function(add_libc_benchmark name file entrypoint_target)
-    set(libc_target libc-${name}-benchmark)
-    add_executable(${libc_target}
-        EXCLUDE_FROM_ALL
-        ${file}
-        LibcMemoryBenchmarkMain.h
-        LibcMemoryBenchmarkMain.cpp
-    )
-
+add_executable(libc-benchmark-main
+foreach(entrypoint_target libc.src.string.memcpy libc.src.string.memset)
     get_target_property(entrypoint_object_file ${entrypoint_target} "OBJECT_FILE_RAW")
-    target_link_libraries(${libc_target} PUBLIC json ${entrypoint_object_file})
-    foreach(configuration "small" "big")
-        add_libc_benchmark_configuration(${libc_target} ${configuration})
-    endforeach()
-endfunction()
-
-add_libc_benchmark(memcpy Memcpy.cpp libc.src.string.memcpy)
-add_libc_benchmark(memset Memset.cpp libc.src.string.memset)
+    target_link_libraries(libc-benchmark-main PUBLIC json ${entrypoint_object_file})

libc/benchmarks/JSON.h

 #include "LibcBenchmark.h"
 #include "LibcMemoryBenchmark.h"
 #include "llvm/Support/JSON.h"
 
 namespace llvm {
 namespace libc_benchmarks {
 
 // Parses a Study from a json string.
-Expected<Study> ParseJsonStudy(StringRef Content);
+Expected<Study> parseJsonStudy(StringRef Content);
 
 // Serialize a Study as json.
-void SerializeToJson(const Study &S, llvm::json::OStream &JOS);
+void serializeToJson(const Study &S, llvm::json::OStream &JOS);
 
 } // namespace libc_benchmarks
 } // namespace llvm
 
 #endif // LLVM_LIBC_UTILS_BENCHMARK_JSON_H

libc/benchmarks/JSON.cpp

if (Value < std::numeric_limits<T>::min() ||
         Value > std::numeric_limits<T>::max())
       return createStringError(errc::io_error, "Out of bound Integer");
     Out = Value;
     return Error::success();
   }
   return createStringError(errc::io_error, "Can't parse Integer");
 }
 
+static Error fromJson(const json::Value &V, bool &Out) {
+  if (auto B = V.getAsBoolean()) {
+    Out = *B;
+    return Error::success();
+  }
+  return createStringError(errc::io_error, "Can't parse Boolean");
+}
+
 static Error fromJson(const json::Value &V, double &Out) {
   if (auto S = V.getAsNumber()) {
     Out = *S;
     return Error::success();
   }
   return createStringError(errc::io_error, "Can't parse Double");
 }
 
 static Error fromJson(const json::Value &V, std::string &Out) {
   if (auto S = V.getAsString()) {
     Out = std::string(*S);
     return Error::success();
   }
   return createStringError(errc::io_error, "Can't parse String");
 }
 
 static Error fromJson(const json::Value &V, uint32_t &Out) {
   return intFromJsonTemplate(V, Out);
 }
 
-static Error fromJson(const json::Value &V, uint8_t &Out) {
-  return intFromJsonTemplate(V, Out);
-}
-
 static Error fromJson(const json::Value &V, int &Out) {
   return intFromJsonTemplate(V, Out);
 }
 
 static Error fromJson(const json::Value &V, libc_benchmarks::Duration &D) {
   if (V.kind() != json::Value::Kind::Number)
     return createStringError(errc::io_error, "Can't parse Duration");
   D = libc_benchmarks::Duration(*V.getAsNumber());
static Error fromJson(const json::Value &V,
   O.map("MinSamples", Out.MinSamples);
   O.map("MaxSamples", Out.MaxSamples);
   O.map("Epsilon", Out.Epsilon);
   O.map("ScalingFactor", Out.ScalingFactor);
   O.map("Log", Out.Log);
   return O.takeError();
 }
 
-static Error fromJson(const json::Value &V, libc_benchmarks::SizeRange &Out) {
-  JsonObjectMapper O(V);
-  O.map("From", Out.From);
-  O.map("To", Out.To);
-  O.map("Step", Out.Step);
-  return O.takeError();
-}
-
 static Error fromJson(const json::Value &V,
                       libc_benchmarks::StudyConfiguration &Out) {
   JsonObjectMapper O(V);
-  O.map("Runs", Out.Runs);
-  O.map("BufferSize", Out.BufferSize);
-  O.map("Size", Out.Size);
-  O.map("AddressAlignment", Out.AddressAlignment);
-  O.map("MemsetValue", Out.MemsetValue);
+  O.map("Function", Out.Function);
+  O.map("NumTrials", Out.NumTrials);
+  O.map("IsSweepMode", Out.IsSweepMode);
+  O.map("SweepModeMaxSize", Out.SweepModeMaxSize);
+  O.map("SizeDistributionName", Out.SizeDistributionName);
+  O.map("AccessAlignment", Out.AccessAlignment);
   O.map("MemcmpMismatchAt", Out.MemcmpMismatchAt);
   return O.takeError();
 }
 
 static Error fromJson(const json::Value &V, libc_benchmarks::CacheInfo &Out) {
   JsonObjectMapper O(V);
   O.map("Type", Out.Type);
   O.map("Level", Out.Level);
   O.map("Size", Out.Size);
   O.map("NumSharing", Out.NumSharing);
   return O.takeError();
 }
 
 static Error fromJson(const json::Value &V, libc_benchmarks::HostState &Out) {
   JsonObjectMapper O(V);
   O.map("CpuName", Out.CpuName);
   O.map("CpuFrequency", Out.CpuFrequency);
   O.map("Caches", Out.Caches);
   return O.takeError();
 }
 
-static Error fromJson(const json::Value &V,
-                      libc_benchmarks::FunctionMeasurements &Out) {
+static Error fromJson(const json::Value &V, libc_benchmarks::Runtime &Out) {
   JsonObjectMapper O(V);
-  O.map("Name", Out.Name);
-  std::vector<uint32_t> Sizes;
-  O.map("Sizes", Sizes);
-  std::vector<libc_benchmarks::Duration> Runtimes;
-  O.map("Runtimes", Runtimes);
-  if (Sizes.size() != Runtimes.size())
-    return createStringError(errc::io_error,
-                             "Measurement Size and Runtime mistmatch");
-  Out.Measurements.resize(Sizes.size());
-  for (size_t I = 0; I < Sizes.size(); ++I) {
-    Out.Measurements[I].Size = Sizes[I];
-    Out.Measurements[I].Runtime = Runtimes[I];
-  }
+  O.map("Host", Out.Host);
+  O.map("BufferSize", Out.BufferSize);
+  O.map("BatchParameterCount", Out.BatchParameterCount);
+  O.map("BenchmarkOptions", Out.BenchmarkOptions);
   return O.takeError();
 }
 
 static Error fromJson(const json::Value &V, libc_benchmarks::Study &Out) {
   JsonObjectMapper O(V);
-  O.map("Host", Out.Host);
-  O.map("Options", Out.Options);
+  O.map("StudyName", Out.StudyName);
+  O.map("Runtime", Out.Runtime);
   O.map("Configuration", Out.Configuration);
-  O.map("Functions", Out.Functions);
+  O.map("Measurements", Out.Measurements);
   return O.takeError();
 }
 
-static double Seconds(const Duration &D) {
+static double seconds(const Duration &D) {
   return std::chrono::duration<double>(D).count();
 }
 
-Expected<Study> ParseJsonStudy(StringRef Content) {
+Expected<Study> parseJsonStudy(StringRef Content) {
   Expected<json::Value> EV = json::parse(Content);
   if (!EV)
     return EV.takeError();
   Study S;
   if (Error E = fromJson(*EV, S))
     return std::move(E);
   return S;
 }
 
-static StringRef Serialize(const BenchmarkLog &L) {
+static StringRef serialize(const BenchmarkLog &L) {
   switch (L) {
   case BenchmarkLog::None:
     return "None";
   case BenchmarkLog::Last:
     return "Last";
   case BenchmarkLog::Full:
     return "Full";
   }
   llvm_unreachable("Unhandled BenchmarkLog value");
 }
 
-static void Serialize(const BenchmarkOptions &BO, json::OStream &JOS) {
-  JOS.object([&]() {
-    JOS.attribute("MinDuration", Seconds(BO.MinDuration));
-    JOS.attribute("MaxDuration", Seconds(BO.MaxDuration));
-    JOS.attribute("InitialIterations", BO.InitialIterations);
-    JOS.attribute("MaxIterations", BO.MaxIterations);
-    JOS.attribute("MinSamples", BO.MinSamples);
-    JOS.attribute("MaxSamples", BO.MaxSamples);
-    JOS.attribute("Epsilon", BO.Epsilon);
-    JOS.attribute("ScalingFactor", BO.ScalingFactor);
-    JOS.attribute("Log", Serialize(BO.Log));
-  });
+static void serialize(const BenchmarkOptions &BO, json::OStream &JOS) {
+  JOS.attribute("MinDuration", seconds(BO.MinDuration));
+  JOS.attribute("MaxDuration", seconds(BO.MaxDuration));
+  JOS.attribute("Log", serialize(BO.Log));
 }
 
-static void Serialize(const CacheInfo &CI, json::OStream &JOS) {
-  JOS.object([&]() {
-    JOS.attribute("Type", CI.Type);
-    JOS.attribute("Level", CI.Level);
-    JOS.attribute("Size", CI.Size);
-    JOS.attribute("NumSharing", CI.NumSharing);
-  });
+static void serialize(const CacheInfo &CI, json::OStream &JOS) {
 }
 
-static void Serialize(const HostState &HS, json::OStream &JOS) {
-  JOS.object([&]() {
-    JOS.attribute("CpuName", HS.CpuName);
-    JOS.attribute("CpuFrequency", HS.CpuFrequency);
-    JOS.attributeArray("Caches", [&]() {
-      for (const auto &CI : HS.Caches)
-        Serialize(CI, JOS);
-    });
+static void serialize(const StudyConfiguration &SC, json::OStream &JOS) {
+  JOS.attribute("Function", SC.Function);
+  JOS.attribute("NumTrials", SC.NumTrials);
+  JOS.attribute("IsSweepMode", SC.IsSweepMode);
+  JOS.attribute("SweepModeMaxSize", SC.SweepModeMaxSize);
+  JOS.attribute("SizeDistributionName", SC.SizeDistributionName);
+  JOS.attribute("AccessAlignment",
+                static_cast<int64_t>(SC.AccessAlignment->value()));
+  JOS.attribute("MemcmpMismatchAt", SC.MemcmpMismatchAt);
+}
+
+static void serialize(const HostState &HS, json::OStream &JOS) {
+      JOS.object([&]() { serialize(CI, JOS); });
   });
 }
 
-static void Serialize(const StudyConfiguration &SC, json::OStream &JOS) {
-  JOS.object([&]() {
-    JOS.attribute("Runs", SC.Runs);
-    JOS.attribute("BufferSize", SC.BufferSize);
-    JOS.attributeObject("Size", [&]() {
-      JOS.attribute("From", SC.Size.From);
-      JOS.attribute("To", SC.Size.To);
-      JOS.attribute("Step", SC.Size.Step);
-    });
-    if (SC.AddressAlignment)
-      JOS.attribute("AddressAlignment",
-                    static_cast<int64_t>(SC.AddressAlignment->value()));
-    JOS.attribute("MemsetValue", SC.MemsetValue);
-    JOS.attribute("MemcmpMismatchAt", SC.MemcmpMismatchAt);
-  });
-}
-
-static void Serialize(const FunctionMeasurements &FM, json::OStream &JOS) {
-  JOS.object([&]() {
-    JOS.attribute("Name", FM.Name);
-    JOS.attributeArray("Sizes", [&]() {
-      for (const auto &M : FM.Measurements)
-        JOS.value(M.Size);
-    });
-    JOS.attributeArray("Runtimes", [&]() {
-      for (const auto &M : FM.Measurements)
-        JOS.value(Seconds(M.Runtime));
-    });
-  });
+static void serialize(const Runtime &RI, json::OStream &JOS) {
+  JOS.attributeObject("Host", [&]() { serialize(RI.Host, JOS); });
+  JOS.attribute("BufferSize", RI.BufferSize);
+  JOS.attribute("BatchParameterCount", RI.BatchParameterCount);
+  JOS.attributeObject("BenchmarkOptions",
+                      [&]() { serialize(RI.BenchmarkOptions, JOS); });
 }
 
-void SerializeToJson(const Study &S, json::OStream &JOS) {
+void serializeToJson(const Study &S, json::OStream &JOS) {
   JOS.object([&]() {
-    JOS.attributeBegin("Host");
-    Serialize(S.Host, JOS);
-    JOS.attributeEnd();
-
-    JOS.attributeBegin("Options");
-    Serialize(S.Options, JOS);
-    JOS.attributeEnd();
-
-    JOS.attributeBegin("Configuration");
-    Serialize(S.Configuration, JOS);
-    JOS.attributeEnd();
-
-    if (!S.Functions.empty()) {
-      JOS.attributeArray("Functions", [&]() {
-        for (const auto &FM : S.Functions)
-          Serialize(FM, JOS);
+    JOS.attribute("StudyName", S.StudyName);
+    JOS.attributeObject("Runtime", [&]() { serialize(S.Runtime, JOS); });
+    JOS.attributeObject("Configuration",
+                        [&]() { serialize(S.Configuration, JOS); });
+    if (!S.Measurements.empty()) {
+      JOS.attributeArray("Measurements", [&]() {
+        for (const auto &M : S.Measurements)
+          JOS.value(seconds(M));
       });
     }
   });
 }
 
 } // namespace libc_benchmarks
 } // namespace llvm

libc/benchmarks/JSONTest.cpp

 using testing::Pointwise;
 
 namespace llvm {
 namespace libc_benchmarks {
 namespace {
 
 Study getStudy() {
   return Study{
-      HostState{
-          "CpuName", 123, {CacheInfo{"A", 1, 2, 3}, CacheInfo{"B", 4, 5, 6}}},
-      BenchmarkOptions{std::chrono::seconds(1), std::chrono::seconds(2), 10,
-                       100, 6, 100, 0.1, 2, BenchmarkLog::Full},
-      StudyConfiguration{2, 3, SizeRange{4, 5, 6}, Align(8), 9, 10},
-      {FunctionMeasurements{"A",
-                            {Measurement{3, std::chrono::seconds(3)},
-                             Measurement{3, std::chrono::seconds(4)}}},
-       FunctionMeasurements{"B", {}}}};
+      "StudyName",
+      Runtime{HostState{"CpuName",
+                        123,
+                        {CacheInfo{"A", 1, 2, 3}, CacheInfo{"B", 4, 5, 6}}},
+              456, 789,
+              BenchmarkOptions{std::chrono::seconds(1), std::chrono::seconds(2),
+                               10, 100, 6, 100, 0.1, 2, BenchmarkLog::Full}},
+      StudyConfiguration{std::string("Function"), 30U, false, 32U,
+                         std::string("Distribution"), Align(16), 3U},
+      {std::chrono::seconds(3), std::chrono::seconds(4)}};
 }
 
-static std::string SerializeToString(const Study &S) {
+static std::string serializeToString(const Study &S) {
   std::string Buffer;
   raw_string_ostream RSO(Buffer);
   json::OStream JOS(RSO);
-  SerializeToJson(S, JOS);
+  serializeToJson(S, JOS);
   return Buffer;
 }
 
 MATCHER(EqualsCacheInfo, "") {
   const CacheInfo &A = ::testing::get<0>(arg);
   const CacheInfo &B = ::testing::get<1>(arg);
   return ExplainMatchResult(AllOf(Field(&CacheInfo::Type, B.Type),
                                   Field(&CacheInfo::Level, B.Level),
                                   Field(&CacheInfo::Size, B.Size),
                                   Field(&CacheInfo::NumSharing, B.NumSharing)),
                             A, result_listener);
 }
 
-auto Equals(const HostState &H) -> auto {
+auto equals(const HostState &H) -> auto {
   return AllOf(
       Field(&HostState::CpuName, H.CpuName),
       Field(&HostState::CpuFrequency, H.CpuFrequency),
       Field(&HostState::Caches, Pointwise(EqualsCacheInfo(), H.Caches)));
 }
 
-auto Equals(const BenchmarkOptions &BO) -> auto {
+auto equals(const StudyConfiguration &SC) -> auto {
+  return AllOf(
+      Field(&StudyConfiguration::Function, SC.Function),
+      Field(&StudyConfiguration::NumTrials, SC.NumTrials),
+      Field(&StudyConfiguration::IsSweepMode, SC.IsSweepMode),
+      Field(&StudyConfiguration::SweepModeMaxSize, SC.SweepModeMaxSize),
+      Field(&StudyConfiguration::SizeDistributionName, SC.SizeDistributionName),
+      Field(&StudyConfiguration::AccessAlignment, SC.AccessAlignment),
+      Field(&StudyConfiguration::MemcmpMismatchAt, SC.MemcmpMismatchAt));
+}
+
+auto equals(const BenchmarkOptions &BO) -> auto {
   return AllOf(
       Field(&BenchmarkOptions::MinDuration, BO.MinDuration),
       Field(&BenchmarkOptions::MaxDuration, BO.MaxDuration),
       Field(&BenchmarkOptions::InitialIterations, BO.InitialIterations),
       Field(&BenchmarkOptions::MaxIterations, BO.MaxIterations),
       Field(&BenchmarkOptions::MinSamples, BO.MinSamples),
       Field(&BenchmarkOptions::MaxSamples, BO.MaxSamples),
       Field(&BenchmarkOptions::Epsilon, BO.Epsilon),
       Field(&BenchmarkOptions::ScalingFactor, BO.ScalingFactor),
       Field(&BenchmarkOptions::Log, BO.Log));
 }
 
-auto Equals(const SizeRange &SR) -> auto {
-  return AllOf(Field(&SizeRange::From, SR.From), Field(&SizeRange::To, SR.To),
-               Field(&SizeRange::Step, SR.Step));
-}
-
-auto Equals(const StudyConfiguration &SC) -> auto {
-  return AllOf(
-      Field(&StudyConfiguration::Runs, SC.Runs),
-      Field(&StudyConfiguration::BufferSize, SC.BufferSize),
-      Field(&StudyConfiguration::Size, Equals(SC.Size)),
-      Field(&StudyConfiguration::AddressAlignment, SC.AddressAlignment),
-      Field(&StudyConfiguration::MemsetValue, SC.MemsetValue),
-      Field(&StudyConfiguration::MemcmpMismatchAt, SC.MemcmpMismatchAt));
-}
-
-MATCHER(EqualsMeasurement, "") {
-  const Measurement &A = ::testing::get<0>(arg);
-  const Measurement &B = ::testing::get<1>(arg);
-  return ExplainMatchResult(AllOf(Field(&Measurement::Size, B.Size),
-                                  Field(&Measurement::Runtime, B.Runtime)),
-                            A, result_listener);
+auto equals(const Runtime &RI) -> auto {
+  return AllOf(Field(&Runtime::Host, equals(RI.Host)),
+               Field(&Runtime::BufferSize, RI.BufferSize),
+               Field(&Runtime::BatchParameterCount, RI.BatchParameterCount),
+               Field(&Runtime::BenchmarkOptions, equals(RI.BenchmarkOptions)));
 }
 
-MATCHER(EqualsFunctions, "") {
-  const FunctionMeasurements &A = ::testing::get<0>(arg);
-  const FunctionMeasurements &B = ::testing::get<1>(arg);
-  return ExplainMatchResult(
-      AllOf(Field(&FunctionMeasurements::Name, B.Name),
-            Field(&FunctionMeasurements::Measurements,
-                  Pointwise(EqualsMeasurement(), B.Measurements))),
-      A, result_listener);
-}
-
-auto Equals(const Study &S) -> auto {
-  return AllOf(
-      Field(&Study::Host, Equals(S.Host)),
-      Field(&Study::Options, Equals(S.Options)),
-      Field(&Study::Configuration, Equals(S.Configuration)),
-      Field(&Study::Functions, Pointwise(EqualsFunctions(), S.Functions)));
+auto equals(const Study &S) -> auto {
+  return AllOf(Field(&Study::StudyName, S.StudyName),
+               Field(&Study::Runtime, equals(S.Runtime)),
+               Field(&Study::Configuration, equals(S.Configuration)),
+               Field(&Study::Measurements, S.Measurements));
 }
 
 TEST(JsonTest, RoundTrip) {
   const Study S = getStudy();
-  auto StudyOrError = ParseJsonStudy(SerializeToString(S));
+  const auto Serialized = serializeToString(S);
+  auto StudyOrError = parseJsonStudy(Serialized);
   if (auto Err = StudyOrError.takeError())
-    EXPECT_FALSE(Err) << "Unexpected error";
+    EXPECT_FALSE(Err) << "Unexpected error : " << Err << "\n" << Serialized;
   const Study &Parsed = *StudyOrError;
-  EXPECT_THAT(Parsed, Equals(S));
+  EXPECT_THAT(Parsed, equals(S)) << Serialized << "\n"
+                                 << serializeToString(Parsed);
 }
 
 TEST(JsonTest, SupplementaryField) {
-  auto Failure = ParseJsonStudy(R"({
+  auto Failure = parseJsonStudy(R"({
       "UnknownField": 10
     }
   )");
   EXPECT_EQ(toString(Failure.takeError()), "Unknown field: UnknownField");
 }
 
 TEST(JsonTest, InvalidType) {
-  auto Failure = ParseJsonStudy(R"({
-      "Options": 1
+  auto Failure = parseJsonStudy(R"({
+      "Runtime": 1
     }
   )");
   EXPECT_EQ(toString(Failure.takeError()), "Expected JSON Object");
 }
 
 TEST(JsonTest, InvalidDuration) {
-  auto Failure = ParseJsonStudy(R"({
-      "Options": {
+  auto Failure = parseJsonStudy(R"({
+      "Runtime": {
+        "BenchmarkOptions": {
           "MinDuration": "Duration should be a Number"
         }
       }
+    }
   )");
   EXPECT_EQ(toString(Failure.takeError()), "Can't parse Duration");
 }
 
 TEST(JsonTest, InvalidAlignType) {
-  auto Failure = ParseJsonStudy(R"({
-      "Configuration":{
-        "AddressAlignment": "Align should be an Integer"
+  auto Failure = parseJsonStudy(R"({
+      "Configuration": {
+        "AccessAlignment": "Align should be an Integer"
       }
     }
   )");
   EXPECT_EQ(toString(Failure.takeError()), "Can't parse Align, not an Integer");
 }
 
 TEST(JsonTest, InvalidAlign) {
-  auto Failure = ParseJsonStudy(R"({
-      "Configuration":{
-        "AddressAlignment":3
+  auto Failure = parseJsonStudy(R"({
+      "Configuration": {
+        "AccessAlignment": 3
       }
     }
   )");
   EXPECT_EQ(toString(Failure.takeError()),
             "Can't parse Align, not a power of two");
 }
 
 TEST(JsonTest, InvalidBenchmarkLogType) {
-  auto Failure = ParseJsonStudy(R"({
-      "Options":{
+  auto Failure = parseJsonStudy(R"({
+      "Runtime": {
+        "BenchmarkOptions":{
           "Log": 3
         }
       }
+    }
   )");
   EXPECT_EQ(toString(Failure.takeError()),
             "Can't parse BenchmarkLog, not a String");
 }
 
 TEST(JsonTest, InvalidBenchmarkLog) {
-  auto Failure = ParseJsonStudy(R"({
-      "Options":{
+  auto Failure = parseJsonStudy(R"({
+      "Runtime": {
+        "BenchmarkOptions":{
           "Log": "Unknown"
         }
       }
+    }
   )");
   EXPECT_EQ(toString(Failure.takeError()),
             "Can't parse BenchmarkLog, invalid value 'Unknown'");
 }
 
 } // namespace
 } // namespace libc_benchmarks
 } // namespace llvm

libc/benchmarks/LibcBenchmark.h

 //   * The last sample used more than MaxIterations iterations.
 //
 // - We also makes sure that the benchmark doesn't run for a too short period of
 // time by defining MinDuration and MinSamples.
 
 #ifndef LLVM_LIBC_UTILS_BENCHMARK_BENCHMARK_H
 #define LLVM_LIBC_UTILS_BENCHMARK_BENCHMARK_H
 
 #include "benchmark/benchmark.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include <array>
 #include <chrono>
 #include <cstdint>
 
 namespace llvm {
 namespace libc_benchmarks {
 
-// Makes sure the binary was compiled in release mode and that frequency
-// governor is set on performance.
-void checkRequirements();
-
 using Duration = std::chrono::duration<double>;
 
 enum class BenchmarkLog {
   None, // Don't keep the internal state of the benchmark.
   Last, // Keep only the last batch.
   Full  // Keep all iterations states, useful for testing or debugging.
 };
 

 
 // A convenient helper to produce a CircularArrayRef from a
 // ByteConstrainedArray.
 template <typename T, size_t N>
 CircularArrayRef<T> cycle(const std::array<T, N> &Container, size_t Size) {
   return {llvm::ArrayRef<T>(Container.cbegin(), Container.cend()), Size};
 }
 
+// Makes sure the binary was compiled in release mode and that frequency
+// governor is set on performance.
+void checkRequirements();
+
 } // namespace libc_benchmarks
 } // namespace llvm
 
 #endif // LLVM_LIBC_UTILS_BENCHMARK_BENCHMARK_H

libc/benchmarks/LibcMemoryBenchmark.h

 //===-- Benchmark memory specific tools -------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // This file complements the `benchmark` header with memory specific tools and
 // benchmarking facilities.
 
 #ifndef LLVM_LIBC_UTILS_BENCHMARK_MEMORY_BENCHMARK_H
 #define LLVM_LIBC_UTILS_BENCHMARK_MEMORY_BENCHMARK_H
 
 #include "LibcBenchmark.h"
-#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Alignment.h"
 #include <cstdint>
 #include <random>
 
 namespace llvm {
 namespace libc_benchmarks {
 
 //--------------
 // Configuration
 //--------------
 
-// Specifies a range of sizes to explore.
-struct SizeRange {
-  uint32_t From = 0;  // Inclusive
-  uint32_t To = 1024; // Inclusive
-  uint32_t Step = 1;
-};
-
-// An object to define how to test a memory function.
 struct StudyConfiguration {
-  // The number of run for the study.
-  uint32_t Runs = 1;
-
-  // The size of the buffers (1 buffer for memset but 2 for memcpy or memcmp).
-  // When testing small sizes, it's important to keep the total allocated
-  // size under the size of the L1 cache (usually 16 or 32KiB). The framework
-  // will also use 2KiB of additional L1 memory to store the function
-  // parameters.
-  uint32_t BufferSize = 8192;
-
-  // The range of sizes to exercise.
-  SizeRange Size;
-
-  MaybeAlign AddressAlignment; //  Unset : Use start of buffer which is at
-                               //         least cache line aligned)
-                               //     1 : Use random address,
-                               //    >1 : Use random address aligned to value.
+  // One of 'memcpy', 'memset', 'memcmp'.
+  // The underlying implementation is always the llvm libc one.
+  // e.g. 'memcpy' will test '__llvm_libc::memcpy'
+  std::string Function;
+
+  // The number of trials to run for this benchmark.
+  // If in SweepMode, each individual sizes are measured 'NumTrials' time.
+  // i.e 'NumTrials' measurements for 0, 'NumTrials' measurements for 1 ...
+  uint32_t NumTrials = 1;
+
+  // Toggles between Sweep Mode and Distribution Mode (default).
+  // See 'SweepModeMaxSize' and 'SizeDistributionName' below.
+  bool IsSweepMode = false;
+
+  // Maximum size to use when measuring a ramp of size values (SweepMode).
+  // The benchmark measures all sizes from 0 to SweepModeMaxSize.
+  // Note: in sweep mode the same size is sampled several times in a row this
+  // will allow the processor to learn it and optimize the branching pattern.
+  // The resulting measurement is likely to be idealized.
+  uint32_t SweepModeMaxSize = 0; // inclusive
+
+  // The name of the distribution to be used to randomize the size parameter.
+  // This is used when SweepMode is false (default).
+  std::string SizeDistributionName;
+
+  // This parameter allows to control how the buffers are accessed during
+  // benchmark:
+  // None : Use a fixed address that is at least cache line aligned,
+  //    1 : Use random address,
+  //   >1 : Use random address aligned to value.
+  MaybeAlign AccessAlignment = None;
 
-  // The value to use for memset.
-  uint8_t MemsetValue = 0;
+  // When Function == 'memcmp', this is the buffers mismatch position.
+  //  0 : Buffers always compare equal,
+  // >0 : Buffers compare different at byte N-1.
+  uint32_t MemcmpMismatchAt = 0;
+};
 
-  // The mismatch position for memcmp.
-  uint32_t MemcmpMismatchAt = 0; //  0 : Buffer compare equal,
-                                 // >0 : Buffer compare different at byte N-1.
+struct Runtime {
+  // Details about the Host (cpu name, cpu frequency, cache hierarchy).
+  HostState Host;
+
+  // The framework will populate this value so all data accessed during the
+  // benchmark will stay in L1 data cache. This includes bookkeeping data.
+  uint32_t BufferSize = 0;
+
+  // This is the number of distinct parameters used in a single batch.
+  // The framework always tests a batch of randomized parameter to prevent the
+  // cpu from learning branching patterns.
+  uint32_t BatchParameterCount = 0;
+
+  // The benchmark options that were used to perform the measurement.
+  // This is decided by the framework.
+  BenchmarkOptions BenchmarkOptions;
 };
 
 //--------
 // Results
 //--------
 
-// The time to run one iteration of the function under test for the specified
-// Size.
-struct Measurement {
-  uint32_t Size = 0;
-  Duration Runtime = {};
-};
-
-// The measurements for a specific function.
-struct FunctionMeasurements {
-  std::string Name;
-  std::vector<Measurement> Measurements;
-};
-
 // The root object containing all the data (configuration and measurements).
 struct Study {
-  HostState Host;
-  BenchmarkOptions Options;
+  std::string StudyName;
+  Runtime Runtime;
   StudyConfiguration Configuration;
-  SmallVector<FunctionMeasurements, 4> Functions;
+  std::vector<Duration> Measurements;
 };
 
+//------
+// Utils
+//------
+
 // Provides an aligned, dynamically allocated buffer.
 class AlignedBuffer {
   char *const Buffer = nullptr;
   size_t Size = 0;
 
 public:
   static constexpr size_t Alignment = 1024;
 
   explicit AlignedBuffer(size_t Size)
-      : Buffer(static_cast<char *>(aligned_alloc(1024, Size))), Size(Size) {}
+      : Buffer(static_cast<char *>(aligned_alloc(Alignment, Size))),
+        Size(Size) {}
   ~AlignedBuffer() { free(Buffer); }
 
   inline char *operator+(size_t Index) { return Buffer + Index; }
   inline const char *operator+(size_t Index) const { return Buffer + Index; }
   inline char &operator[](size_t Index) { return Buffer[Index]; }
   inline const char &operator[](size_t Index) const { return Buffer[Index]; }
   inline char *begin() { return Buffer; }
   inline char *end() { return Buffer + Size; }
 };
 
-// Implements the ParameterProvider abstraction needed by the `benchmark`
-// function. This implementation makes sure that all parameters will fit into
-// `StorageSize` bytes. The total memory accessed during benchmark should be
-// less than the data L1 cache, that is the storage for the ParameterProvider
-// and the memory buffers.
-template <typename Context, size_t StorageSize = 8 * 1024>
-class SmallParameterProvider {
-  using ParameterType = typename Context::ParameterType;
-  ByteConstrainedArray<ParameterType, StorageSize> Parameters;
-  size_t LastIterations;
-  Context &Ctx;
-
-public:
-  explicit SmallParameterProvider(Context &C) : Ctx(C) {}
-  SmallParameterProvider(const SmallParameterProvider &) = delete;
-  SmallParameterProvider &operator=(const SmallParameterProvider &) = delete;
-
-  // Useful to compute the histogram of the size parameter.
-  CircularArrayRef<ParameterType> getLastBatch() const {
-    return cycle(Parameters, LastIterations);
-  }
-
-  // Implements the interface needed by the `benchmark` function.
-  CircularArrayRef<ParameterType> generateBatch(size_t Iterations) {
-    LastIterations = Iterations;
-    Ctx.Randomize(Parameters);
-    return getLastBatch();
-  }
-};
-
 // Helper to generate random buffer offsets that satisfy the configuration
 // constraints.
 class OffsetDistribution {
   std::uniform_int_distribution<uint32_t> Distribution;
   uint32_t Factor;
 
 public:
-  explicit OffsetDistribution(const StudyConfiguration &Conf);
+  explicit OffsetDistribution(size_t BufferSize, size_t MaxSizeValue,
+                              MaybeAlign AccessAlignment);
 
   template <class Generator> uint32_t operator()(Generator &G) {
     return Distribution(G) * Factor;
   }
 };
 
 // Helper to generate random buffer offsets that satisfy the configuration
 // constraints. It is specifically designed to benchmark `memcmp` functions
 // where we may want the Nth byte to differ.
 class MismatchOffsetDistribution {
   std::uniform_int_distribution<size_t> MismatchIndexSelector;
   llvm::SmallVector<uint32_t, 16> MismatchIndices;
   const uint32_t MismatchAt;
 
 public:
-  explicit MismatchOffsetDistribution(const StudyConfiguration &Conf);
+  explicit MismatchOffsetDistribution(size_t BufferSize, size_t MaxSizeValue,
+                                      size_t MismatchAt);
 
   explicit operator bool() const { return !MismatchIndices.empty(); }
 
   const llvm::SmallVectorImpl<uint32_t> &getMismatchIndices() const {
     return MismatchIndices;
   }
 
   template <class Generator> uint32_t operator()(Generator &G, uint32_t Size) {

libc/benchmarks/LibcMemoryBenchmark.cpp

 namespace llvm {
 namespace libc_benchmarks {
 
 // Returns a distribution that samples the buffer to satisfy the required
 // alignment.
 // When alignment is set, the distribution is scaled down by `Factor` and scaled
 // up again by the same amount during sampling.
 static std::uniform_int_distribution<uint32_t>
-GetOffsetDistribution(const StudyConfiguration &Conf) {
-  if (Conf.AddressAlignment &&
-      *Conf.AddressAlignment > AlignedBuffer::Alignment)
+getOffsetDistribution(size_t BufferSize, size_t MaxSizeValue,
+                      MaybeAlign AccessAlignment) {
+  if (AccessAlignment && *AccessAlignment > AlignedBuffer::Alignment)
     report_fatal_error(
-        "AddressAlignment must be less or equal to AlignedBuffer::Alignment");
-  if (!Conf.AddressAlignment)
+        "AccessAlignment must be less or equal to AlignedBuffer::Alignment");
+  if (!AccessAlignment)
     return std::uniform_int_distribution<uint32_t>(0, 0); // Always 0.
   // If we test up to Size bytes, the returned offset must stay under
   // BuffersSize - Size.
-  int64_t MaxOffset = Conf.BufferSize;
-  MaxOffset -= Conf.Size.To;
+  int64_t MaxOffset = BufferSize;
+  MaxOffset -= MaxSizeValue;
   MaxOffset -= 1;
   if (MaxOffset < 0)
     report_fatal_error(
         "BufferSize too small to exercise specified Size configuration");
-  MaxOffset /= Conf.AddressAlignment->value();
+  MaxOffset /= AccessAlignment->value();
   return std::uniform_int_distribution<uint32_t>(0, MaxOffset);
 }
 
-OffsetDistribution::OffsetDistribution(const StudyConfiguration &Conf)
-    : Distribution(GetOffsetDistribution(Conf)),
-      Factor(Conf.AddressAlignment.valueOrOne().value()) {}
+OffsetDistribution::OffsetDistribution(size_t BufferSize, size_t MaxSizeValue,
+                                       MaybeAlign AccessAlignment)
+    : Distribution(
+          getOffsetDistribution(BufferSize, MaxSizeValue, AccessAlignment)),
+      Factor(AccessAlignment.valueOrOne().value()) {}
 
 // Precomputes offset where to insert mismatches between the two buffers.
-MismatchOffsetDistribution::MismatchOffsetDistribution(
-    const StudyConfiguration &Conf)
-    : MismatchAt(Conf.MemcmpMismatchAt) {
+MismatchOffsetDistribution::MismatchOffsetDistribution(size_t BufferSize,
+                                                       size_t MaxSizeValue,
+                                                       size_t MismatchAt)
+    : MismatchAt(MismatchAt) {
   if (MismatchAt <= 1)
     return;
-  const auto ToSize = Conf.Size.To;
-  for (size_t I = ToSize + 1; I < Conf.BufferSize; I += ToSize)
+  for (size_t I = MaxSizeValue + 1; I < BufferSize; I += MaxSizeValue)
     MismatchIndices.push_back(I);
   if (MismatchIndices.empty())
-    llvm::report_fatal_error("Unable to generate mismatch");
+    report_fatal_error("Unable to generate mismatch");
   MismatchIndexSelector =
       std::uniform_int_distribution<size_t>(0, MismatchIndices.size() - 1);
 }
 
 } // namespace libc_benchmarks
 } // namespace llvm

libc/benchmarks/LibcMemoryBenchmarkMain.h

-//===-- BenchmarkRunner interface -------------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_LIBC_UTILS_BENCHMARK_MEMORY_BENCHMARK_MAIN_H
-#define LLVM_LIBC_UTILS_BENCHMARK_MEMORY_BENCHMARK_MAIN_H
-
-#include "LibcBenchmark.h"
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/StringRef.h"
-
-namespace llvm {
-namespace libc_benchmarks {
-
-// Each memory function benchmark implements this interface.
-// It is used by the main function to run all benchmarks in a uniform manner.
-class BenchmarkRunner {
-public:
-  virtual ~BenchmarkRunner() {}
-
-  // Returns a list of all available functions to test.
-  virtual ArrayRef<StringRef> getFunctionNames() const = 0;
-
-  // Performs the benchmarking for a particular FunctionName and Size.
-  virtual BenchmarkResult benchmark(const BenchmarkOptions &Options,
-                                    StringRef FunctionName, size_t Size) = 0;
-};
-
-} // namespace libc_benchmarks
-} // namespace llvm
-
-#endif // LLVM_LIBC_UTILS_BENCHMARK_MEMORY_BENCHMARK_MAIN_H

libc/benchmarks/LibcMemoryBenchmarkMain.cpp

 //===-- Benchmark ---------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-#include "LibcMemoryBenchmarkMain.h"
 #include "JSON.h"
 #include "LibcBenchmark.h"
 #include "LibcMemoryBenchmark.h"
+#include "MemorySizeDistributions.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
 
-#include <string>
+namespace __llvm_libc {
+
+extern void *memcpy(void *__restrict, const void *__restrict, size_t);
+extern void *memset(void *, int, size_t);
+
+} // namespace __llvm_libc
 
 namespace llvm {
 namespace libc_benchmarks {
 
+enum Function { memcpy, memset };
+
+static cl::opt<std::string>
+    StudyName("study-name", cl::desc("The name for this study"), cl::Required);
+
+static cl::opt<Function>
+    MemoryFunction("function", cl::desc("Sets the function to benchmark:"),
+                   cl::values(clEnumVal(memcpy, "__llvm_libc::memcpy"),
+                              clEnumVal(memset, "__llvm_libc::memset")),
+                   cl::Required);
+
 static cl::opt<std::string>
-    Configuration("conf", cl::desc("Specify configuration filename"),
-                  cl::value_desc("filename"), cl::init(""));
+    SizeDistributionName("size-distribution-name",
+                         cl::desc("The name of the distribution to use"));
 
-static cl::opt<std::string> Output("o", cl::desc("Specify output filename"),
+static cl::opt<bool>
+    SweepMode("sweep-mode",
+              cl::desc("If set, benchmark all sizes from 0 to sweep-max-size"));
+
+static cl::opt<uint32_t>
+    SweepMaxSize("sweep-max-size",
+                 cl::desc("The maximum size to use in sweep-mode"),
+                 cl::init(256));
+
+static cl::opt<uint32_t>
+    AlignedAccess("aligned-access",
+                  cl::desc("The alignment to use when accessing the buffers\n"
+                           "Default is unaligned\n"
+                           "Use 0 to disable address randomization"),
+                  cl::init(1));
+
+static cl::opt<std::string> Output("output",
+                                   cl::desc("Specify output filename"),
                                    cl::value_desc("filename"), cl::init("-"));
 
-extern std::unique_ptr<BenchmarkRunner>
-getRunner(const StudyConfiguration &Conf);
+static cl::opt<uint32_t>
+    NumTrials("num-trials", cl::desc("The number of benchmarks run to perform"),
+              cl::init(1));
+
+static constexpr int64_t KiB = 1024;
+static constexpr int64_t ParameterStorageBytes = 4 * KiB;
+static constexpr int64_t L1LeftAsideBytes = 1 * KiB;
+
+struct ParameterType {
+  unsigned OffsetBytes : 16; // max : 16 KiB - 1
+  unsigned SizeBytes : 16;   // max : 16 KiB - 1
+};
+
+struct MemcpyBenchmark {
+  static constexpr auto GetDistributions = &getMemcpySizeDistributions;
+  static constexpr size_t BufferCount = 2;
+  static void amend(Study &S) { S.Configuration.Function = "memcpy"; }
+
+  MemcpyBenchmark(const size_t BufferSize)
+      : SrcBuffer(BufferSize), DstBuffer(BufferSize) {}
+
+  inline auto functor() {
+    return [this](ParameterType P) {
+      __llvm_libc::memcpy(DstBuffer + P.OffsetBytes, SrcBuffer + P.OffsetBytes,
+                          P.SizeBytes);
+      return DstBuffer + P.OffsetBytes;
+    };
+  }
 
-void Main() {
-#ifndef NDEBUG
-  static_assert(
-      false,
-      "For reproducibility benchmarks should not be compiled in DEBUG mode.");
-#endif
-  checkRequirements();
-  ErrorOr<std::unique_ptr<MemoryBuffer>> MB =
-      MemoryBuffer::getFileOrSTDIN(Configuration);
-  if (!MB)
-    report_fatal_error(
-        Twine("Could not open configuration file: ").concat(Configuration));
-  auto ErrorOrStudy = ParseJsonStudy((*MB)->getBuffer());
-  if (!ErrorOrStudy)
-    report_fatal_error(ErrorOrStudy.takeError());
-
-  const auto StudyPrototype = *ErrorOrStudy;
-
-  Study S;
-  S.Host = HostState::get();
-  S.Options = StudyPrototype.Options;
-  S.Configuration = StudyPrototype.Configuration;
-
-  const auto Runs = S.Configuration.Runs;
-  const auto &SR = S.Configuration.Size;
-  std::unique_ptr<BenchmarkRunner> Runner = getRunner(S.Configuration);
-  const size_t TotalSteps =
-      Runner->getFunctionNames().size() * Runs * ((SR.To - SR.From) / SR.Step);
-  size_t Steps = 0;
-  for (auto FunctionName : Runner->getFunctionNames()) {
-    FunctionMeasurements FM;
-    FM.Name = std::string(FunctionName);
-    for (size_t Run = 0; Run < Runs; ++Run) {
-      for (uint32_t Size = SR.From; Size <= SR.To; Size += SR.Step) {
-        const auto Result = Runner->benchmark(S.Options, FunctionName, Size);
-        Measurement Measurement;
-        Measurement.Runtime = Result.BestGuess;
-        Measurement.Size = Size;
-        FM.Measurements.push_back(Measurement);
-        outs() << format("%3d%% run: %2d / %2d size: %5d ",
-                         (Steps * 100 / TotalSteps), Run, Runs, Size)
-               << FunctionName
-               << "                                                  \r";
-        ++Steps;
-      }
-    }
-    S.Functions.push_back(std::move(FM));
+  AlignedBuffer SrcBuffer;
+  AlignedBuffer DstBuffer;
+};
+
+struct MemsetBenchmark {
+  static constexpr auto GetDistributions = &getMemsetSizeDistributions;
+  static constexpr size_t BufferCount = 1;
+  static void amend(Study &S) { S.Configuration.Function = "memset"; }
+
+  MemsetBenchmark(const size_t BufferSize) : DstBuffer(BufferSize) {}
+
+  inline auto functor() {
+    return [this](ParameterType P) {
+      __llvm_libc::memset(DstBuffer + P.OffsetBytes, P.OffsetBytes & 0xFF,
+                          P.SizeBytes);
+      return DstBuffer + P.OffsetBytes;
+    };
+  }
+
+  AlignedBuffer DstBuffer;
+};
+
+template <typename Benchmark> struct Harness : Benchmark {
+  using Benchmark::functor;
+
+  Harness(const size_t BufferSize, size_t BatchParameterCount,
+          std::function<unsigned()> SizeSampler,
+          std::function<unsigned()> OffsetSampler)
+      : Benchmark(BufferSize), BufferSize(BufferSize),
+        BatchParameterCount(BatchParameterCount),
+        Parameters(BatchParameterCount), SizeSampler(SizeSampler),
+        OffsetSampler(OffsetSampler) {}
+
+  CircularArrayRef<ParameterType> generateBatch(size_t Iterations) {
+    for (auto &P : Parameters) {
+      P.OffsetBytes = OffsetSampler();
+      P.SizeBytes = SizeSampler();
+      if (P.OffsetBytes + P.SizeBytes >= BufferSize)
+        report_fatal_error("Call would result in buffer overflow");
+    }
+    return cycle(makeArrayRef(Parameters), Iterations);
+  }
+
+private:
+  const size_t BufferSize;
+  const size_t BatchParameterCount;
+  std::vector<ParameterType> Parameters;
+  std::function<unsigned()> SizeSampler;
+  std::function<unsigned()> OffsetSampler;
+};
+
+struct IBenchmark {
+  virtual ~IBenchmark() {}
+  virtual Study run() = 0;
+};
+
+size_t getL1DataCacheSize() {
+  const std::vector<CacheInfo> &CacheInfos = HostState::get().Caches;
+  const auto IsL1DataCache = [](const CacheInfo &CI) {
+    return CI.Type == "Data" && CI.Level == 1;
+  };
+  const auto CacheIt = find_if(CacheInfos, IsL1DataCache);
+  if (CacheIt != CacheInfos.end())
+    return CacheIt->Size;
+  report_fatal_error("Unable to read L1 Cache Data Size");
+}
+
+template <typename Benchmark> struct MemfunctionBenchmark : IBenchmark {
+  MemfunctionBenchmark(int64_t L1Size = getL1DataCacheSize())
+      : AvailableSize(L1Size - L1LeftAsideBytes - ParameterStorageBytes),
+        BufferSize(AvailableSize / Benchmark::BufferCount),
+        BatchParameterCount(BufferSize / sizeof(ParameterType)) {
+    // Handling command line flags
+    if (AvailableSize <= 0 || BufferSize <= 0 || BatchParameterCount < 100)
+      report_fatal_error("Not enough L1 cache");
+
+    if (!isPowerOfTwoOrZero(AlignedAccess))
+      report_fatal_error(AlignedAccess.ArgStr +
+                         Twine(" must be a power of two or zero"));
+
+    const bool HasDistributionName = !SizeDistributionName.empty();
+    if (SweepMode && HasDistributionName)
+      report_fatal_error("Select only one of `--" + Twine(SweepMode.ArgStr) +
+                         "` or `--" + Twine(SizeDistributionName.ArgStr) + "`");
+
+    if (SweepMode) {
+      MaxSizeValue = SweepMaxSize;
+    } else {
+      std::map<StringRef, MemorySizeDistribution> Map;
+      for (MemorySizeDistribution Distribution : Benchmark::GetDistributions())
+        Map[Distribution.Name] = Distribution;
+      if (Map.count(SizeDistributionName) == 0) {
+        std::string Message;
+        raw_string_ostream Stream(Message);
+        Stream << "Unknown --" << SizeDistributionName.ArgStr << "='"
+               << SizeDistributionName << "', available distributions:\n";
+        for (const auto &Pair : Map)
+          Stream << "'" << Pair.first << "'\n";
+        report_fatal_error(Stream.str());
+      }
+      SizeDistribution = Map[SizeDistributionName];
+      MaxSizeValue = SizeDistribution.Probabilities.size() - 1;
+    }
+
+    // Setup study.
+    Study.StudyName = StudyName;
+    Runtime &RI = Study.Runtime;
+    RI.Host = HostState::get();
+    RI.BufferSize = BufferSize;
+    RI.BatchParameterCount = BatchParameterCount;
+
+    BenchmarkOptions &BO = RI.BenchmarkOptions;
+    BO.MinDuration = std::chrono::milliseconds(1);
+    BO.MaxDuration = std::chrono::seconds(1);
+    BO.MaxIterations = 10'000'000U;
+    BO.MinSamples = 4;
+    BO.MaxSamples = 1000;
+    BO.Epsilon = 0.01; // 1%
+    BO.ScalingFactor = 1.4;
+
+    StudyConfiguration &SC = Study.Configuration;
+    SC.NumTrials = NumTrials;
+    SC.IsSweepMode = SweepMode;
+    if (SweepMode)
+      SC.SweepModeMaxSize = SweepMaxSize;
+    else
+      SC.SizeDistributionName = SizeDistributionName;
+    SC.AccessAlignment = MaybeAlign(AlignedAccess);
+
+    // Delegate specific flags and configuration.
+    Benchmark::amend(Study);
+  }
+
+  Study run() override {
+    if (SweepMode)
+      runSweepMode();
+    else
+      runDistributionMode();
+    return Study;
+
+private:
+  const int64_t AvailableSize;
+  const int64_t BufferSize;
+  const size_t BatchParameterCount;
+  size_t MaxSizeValue = 0;
+  MemorySizeDistribution SizeDistribution;
+  Study Study;
+  std::mt19937_64 Gen;
+
+  static constexpr bool isPowerOfTwoOrZero(size_t Value) {
+    return (Value & (Value - 1U)) == 0;
+  }
+
+  std::function<unsigned()> geOffsetSampler() {
+    return [this]() {
+      static OffsetDistribution OD(BufferSize, MaxSizeValue,
+                                   Study.Configuration.AccessAlignment);
+      return OD(Gen);
+    };
+
+  std::function<unsigned()> getSizeSampler() {
+    return [this]() {
+      static std::discrete_distribution<unsigned> Distribution(
+          SizeDistribution.Probabilities.begin(),
+          SizeDistribution.Probabilities.end());
+      return Distribution(Gen);
+    };
+  }
+
+  void reportProgress(BenchmarkStatus BS) {
+    const size_t TotalSteps = Study.Measurements.capacity();
+    const size_t Steps = Study.Measurements.size();
+    const size_t Percent = 100 * Steps / TotalSteps;
+    size_t I = 0;
+    errs() << '[';
+    for (; I <= Percent; ++I)
+      errs() << '#';
+    for (; I <= 100; ++I)
+      errs() << '_';
+    errs() << "] " << Percent << "%\r";
   }
 
+  void runTrials(const BenchmarkOptions &Options,
+                 std::function<unsigned()> SizeSampler,
+                 std::function<unsigned()> OffsetSampler) {
+    Harness<Benchmark> B(BufferSize, BatchParameterCount, SizeSampler,
+                         OffsetSampler);
+    for (size_t i = 0; i < NumTrials; ++i) {
+      const BenchmarkResult Result = benchmark(Options, B, B.functor());
+      Study.Measurements.push_back(Result.BestGuess);
+      reportProgress(Result.TerminationStatus);
+    }
+  }
+
+  void runSweepMode() {
+    Study.Measurements.reserve(NumTrials * SweepMaxSize);
+
+    BenchmarkOptions &BO = Study.Runtime.BenchmarkOptions;
+    BO.MinDuration = std::chrono::milliseconds(1);
+    BO.InitialIterations = 100;
+
+    for (size_t Size = 0; Size <= SweepMaxSize; ++Size) {
+      const auto SizeSampler = [Size]() { return Size; };
+      runTrials(BO, SizeSampler, geOffsetSampler());
+    }
+  }
+
+  void runDistributionMode() {
+    Study.Measurements.reserve(NumTrials);
+
+    BenchmarkOptions &BO = Study.Runtime.BenchmarkOptions;
+    BO.MinDuration = std::chrono::milliseconds(10);
+    BO.InitialIterations = BatchParameterCount * 10;
+
+    runTrials(BO, getSizeSampler(), geOffsetSampler());
+  }
+};
+
+std::unique_ptr<IBenchmark> getMemfunctionBenchmark() {
+  switch (MemoryFunction) {
+  case memcpy:
+    return std::make_unique<MemfunctionBenchmark<MemcpyBenchmark>>();
+  case memset:
+    return std::make_unique<MemfunctionBenchmark<MemsetBenchmark>>();
+  }
+}
+
+void writeStudy(const Study &S) {
   std::error_code EC;
   raw_fd_ostream FOS(Output, EC);
   if (EC)
     report_fatal_error(Twine("Could not open file: ")
                            .concat(EC.message())
                            .concat(", ")
                            .concat(Output));
   json::OStream JOS(FOS);
-  SerializeToJson(S, JOS);
+  serializeToJson(S, JOS);
+}
+
+void main() {
+  checkRequirements();
+  auto MB = getMemfunctionBenchmark();
+  writeStudy(MB->run());
 }
 
 } // namespace libc_benchmarks
 } // namespace llvm
 
 int main(int argc, char **argv) {
   llvm::cl::ParseCommandLineOptions(argc, argv);
-  llvm::libc_benchmarks::Main();
+#ifndef NDEBUG
+  static_assert(
+      false,
+      "For reproducibility benchmarks should not be compiled in DEBUG mode.");
+#endif
+  llvm::libc_benchmarks::main();
   return EXIT_SUCCESS;
 }

libc/benchmarks/LibcMemoryBenchmarkTest.cpp

 }
 
 TEST(AlignedBuffer, Empty) {
   AlignedBuffer AB(0);
   EXPECT_EQ(std::distance(AB.begin(), AB.end()), 0U);
 }
 
 TEST(OffsetDistribution, AlignToBegin) {
-  StudyConfiguration Conf;
-  Conf.BufferSize = 8192;
-  Conf.AddressAlignment = None;
-
-  OffsetDistribution OD(Conf);
+  const size_t BufferSize = 8192;
+  OffsetDistribution OD(BufferSize, 1024, None);
   std::default_random_engine Gen;
   for (size_t I = 0; I <= 10; ++I)
     EXPECT_EQ(OD(Gen), 0U);
 }
 
 TEST(OffsetDistribution, NoAlignment) {
-  StudyConfiguration Conf;
-  Conf.BufferSize = 8192;
-  Conf.Size.To = 1;
-
-  OffsetDistribution OD(Conf);
+  const size_t BufferSize = 8192;
+  OffsetDistribution OD(BufferSize, 1, Align(1));
   std::default_random_engine Gen;
   for (size_t I = 0; I <= 10; ++I)
     EXPECT_THAT(OD(Gen), AllOf(Ge(0U), Lt(8192U)));
 }
 
 MATCHER_P(IsDivisibleBy, n, "") {
   *result_listener << "where the remainder is " << (arg % n);
   return (arg % n) == 0;
 }
 
 TEST(OffsetDistribution, Aligned) {
-  StudyConfiguration Conf;
-  Conf.BufferSize = 8192;
-  Conf.AddressAlignment = Align(16);
-  Conf.Size.To = 1;
-
-  OffsetDistribution OD(Conf);
+  const size_t BufferSize = 8192;
+  OffsetDistribution OD(BufferSize, 1, Align(16));
   std::default_random_engine Gen;
   for (size_t I = 0; I <= 10; ++I)
     EXPECT_THAT(OD(Gen), AllOf(Ge(0U), Lt(8192U), IsDivisibleBy(16U)));
 }
 
 TEST(MismatchOffsetDistribution, EqualBufferDisablesDistribution) {
-  StudyConfiguration Conf;
-  Conf.MemcmpMismatchAt = 0; // buffer are equal.
+  const size_t BufferSize = 8192;
+  const uint32_t MismatchAt = 0; // buffer are equal.
 
-  MismatchOffsetDistribution MOD(Conf);
+  MismatchOffsetDistribution MOD(BufferSize, 1024, MismatchAt);
   EXPECT_FALSE(MOD);
 }
 
 TEST(MismatchOffsetDistribution, DifferentBufferDisablesDistribution) {
-  StudyConfiguration Conf;
-  Conf.MemcmpMismatchAt = 1; // buffer are different.
+  const size_t BufferSize = 8192;
+  const uint32_t MismatchAt = 1; // buffer are different.
 
-  MismatchOffsetDistribution MOD(Conf);
+  MismatchOffsetDistribution MOD(BufferSize, 1024, MismatchAt);
   EXPECT_FALSE(MOD);
 }
 
 TEST(MismatchOffsetDistribution, MismatchAt2) {
-  const uint32_t MismatchAt = 2;
-  const uint32_t ToSize = 4;
-  StudyConfiguration Conf;
-  Conf.BufferSize = 16;
-  Conf.MemcmpMismatchAt = MismatchAt; // buffer are different at position 2.
-  Conf.Size.To = ToSize;
+  const size_t BufferSize = 16;
+  const uint32_t MismatchAt = 2; // buffer are different at position 2.
+  const uint32_t MaxSize = 4;
 
-  MismatchOffsetDistribution MOD(Conf);
+  MismatchOffsetDistribution MOD(BufferSize, MaxSize, MismatchAt);
   EXPECT_TRUE(MOD);
-  // We test equality up to ToSize (=4) so we need spans of 4 equal bytes spaced
-  // by one mismatch.
+  // We test equality up to MaxSize (=4) so we need spans of 4 equal bytes
+  // spaced by one mismatch.
   EXPECT_THAT(MOD.getMismatchIndices(), ElementsAre(5, 9, 13));
   std::default_random_engine Gen;
   for (size_t Iterations = 0; Iterations <= 10; ++Iterations) {
-    for (size_t Size = Conf.Size.From; Size <= ToSize; ++Size) {
+    for (size_t Size = 0; Size <= MaxSize; ++Size) {
       if (Size >= MismatchAt)
         EXPECT_THAT(MOD(Gen, Size),
                     AnyOf(5 - MismatchAt, 9 - MismatchAt, 13 - MismatchAt));
       else
         EXPECT_THAT(MOD(Gen, Size),
                     AnyOf(5 - Size - 1, 9 - Size - 1, 13 - Size - 1));
     }
   }
 }
 
 } // namespace
 } // namespace libc_benchmarks
 } // namespace llvm

libc/benchmarks/Memcmp.cpp

-//===-- Benchmark memcmp implementation -----------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include "LibcBenchmark.h"
-#include "LibcMemoryBenchmark.h"
-#include "LibcMemoryBenchmarkMain.h"
-#include "llvm/ADT/StringSwitch.h"
-#include "llvm/Support/raw_ostream.h"
-
-namespace llvm {
-namespace libc_benchmarks {
-
-// The context encapsulates the buffers, parameters and the measure.
-struct MemcmpContext : public BenchmarkRunner {
-  using FunctionPrototype = int (*)(const void *, const void *, size_t);
-
-  struct ParameterType {
-    uint16_t Offset = 0;
-  };
-
-  explicit MemcmpContext(const StudyConfiguration &Conf)
-      : MOD(Conf), OD(Conf), ABuffer(Conf.BufferSize), BBuffer(Conf.BufferSize),
-        PP(*this) {
-    std::uniform_int_distribution<char> Dis;
-    // Generate random buffer A.
-    for (size_t I = 0; I < Conf.BufferSize; ++I)
-      ABuffer[I] = Dis(Gen);
-    // Copy buffer A to B.
-    ::memcpy(BBuffer.begin(), ABuffer.begin(), Conf.BufferSize);
-    if (Conf.MemcmpMismatchAt == 0)
-      return; // all same.
-    else if (Conf.MemcmpMismatchAt == 1)
-      for (char &c : BBuffer)
-        ++c; // all different.
-    else
-      for (const auto I : MOD.getMismatchIndices())
-        ++BBuffer[I];
-  }
-
-  // Needed by the ParameterProvider to update the current batch of parameter.
-  void Randomize(MutableArrayRef<ParameterType> Parameters) {
-    if (MOD)
-      for (auto &P : Parameters)
-        P.Offset = MOD(Gen, CurrentSize);
-    else
-      for (auto &P : Parameters)
-        P.Offset = OD(Gen);
-  }
-
-  ArrayRef<StringRef> getFunctionNames() const override {
-    static std::array<StringRef, 1> kFunctionNames = {"memcmp"};
-    return kFunctionNames;
-  }
-
-  BenchmarkResult benchmark(const BenchmarkOptions &Options,
-                            StringRef FunctionName, size_t Size) override {
-    CurrentSize = Size;
-    // FIXME: Add `bcmp` once we're guaranteed that the function is provided.
-    FunctionPrototype Function =
-        StringSwitch<FunctionPrototype>(FunctionName).Case("memcmp", &::memcmp);
-    return llvm::libc_benchmarks::benchmark(
-        Options, PP, [this, Function, Size](ParameterType p) {
-          return Function(ABuffer + p.Offset, BBuffer + p.Offset, Size);
-        });
-  }
-
-private:
-  std::default_random_engine Gen;
-  MismatchOffsetDistribution MOD;
-  OffsetDistribution OD;
-  size_t CurrentSize = 0;
-  AlignedBuffer ABuffer;
-  AlignedBuffer BBuffer;
-  SmallParameterProvider<MemcmpContext> PP;
-};
-
-std::unique_ptr<BenchmarkRunner> getRunner(const StudyConfiguration &Conf) {
-  return std::make_unique<MemcmpContext>(Conf);
-}
-
-} // namespace libc_benchmarks
-} // namespace llvm

libc/benchmarks/Memcpy.cpp

-//===-- Benchmark memcpy implementation -----------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include "LibcBenchmark.h"
-#include "LibcMemoryBenchmark.h"
-#include "LibcMemoryBenchmarkMain.h"
-#include "llvm/ADT/StringSwitch.h"
-#include "llvm/Support/raw_ostream.h"
-#include <memory>
-
-namespace __llvm_libc {
-extern void *memcpy(void *__restrict, const void *__restrict, size_t);
-} // namespace __llvm_libc
-
-namespace llvm {
-namespace libc_benchmarks {
-
-// The context encapsulates the buffers, parameters and the measure.
-struct MemcpyContext : public BenchmarkRunner {
-  using FunctionPrototype = void *(*)(void *, const void *, size_t);
-
-  struct ParameterType {
-    uint16_t SrcOffset = 0;
-    uint16_t DstOffset = 0;
-  };
-
-  explicit MemcpyContext(const StudyConfiguration &Conf)
-      : OD(Conf), SrcBuffer(Conf.BufferSize), DstBuffer(Conf.BufferSize),
-        PP(*this) {}
-
-  // Needed by the ParameterProvider to update the current batch of parameter.
-  void Randomize(MutableArrayRef<ParameterType> Parameters) {
-    for (auto &P : Parameters) {
-      P.DstOffset = OD(Gen);
-      P.SrcOffset = OD(Gen);
-    }
-  }
-
-  ArrayRef<StringRef> getFunctionNames() const override {
-    static std::array<StringRef, 1> kFunctionNames = {"memcpy"};
-    return kFunctionNames;
-  }
-
-  BenchmarkResult benchmark(const BenchmarkOptions &Options,
-                            StringRef FunctionName, size_t Size) override {
-    FunctionPrototype Function = StringSwitch<FunctionPrototype>(FunctionName)
-                                     .Case("memcpy", &__llvm_libc::memcpy);
-    return llvm::libc_benchmarks::benchmark(
-        Options, PP, [this, Function, Size](ParameterType p) {
-          Function(DstBuffer + p.DstOffset, SrcBuffer + p.SrcOffset, Size);
-          return DstBuffer + p.DstOffset;
-        });
-  }
-
-private:
-  std::default_random_engine Gen;
-  OffsetDistribution OD;
-  AlignedBuffer SrcBuffer;
-  AlignedBuffer DstBuffer;
-  SmallParameterProvider<MemcpyContext> PP;
-};
-
-std::unique_ptr<BenchmarkRunner> getRunner(const StudyConfiguration &Conf) {
-  return std::make_unique<MemcpyContext>(Conf);
-}
-
-} // namespace libc_benchmarks
-} // namespace llvm

libc/benchmarks/MemorySizeDistributions.cpp

 static constexpr double kMemcpyGoogleB[] = {0.0755418, 0.0204334, 0.00464396, 0.0473684, 0.0260062, 0.00371517, 0.0145511, 0.00433437, 0.0377709, 0.113313, 0.0501548, 0.0108359, 0.00154799, 0.000619195, 0.000928793, 0.00154799, 0.237152, 0.00897833, 0.0733746, 0.00402477, 0.00216718, 0.00278638, 0.0216718, 0.00154799, 0.000619195, 0.000619195, 0.00309598, 0.00123839, 0.0198142, 0.00216718, 0.000928793, 0.00216718, 0.0291022, 0.00278638, 0.000619195, 0.00247678, 0.000619195, 0.00247678, 0.000928793, 0.0111455, 0.00588235, 0.000309598, 0.000619195, 0.000619195, 0, 0.0216718, 0.00123839, 0.00340557, 0.00123839, 0.000619195, 0.000928793, 0.0201238, 0.0260062, 0.000619195, 0, 0.00309598, 0.00897833, 0.00866873, 0.000928793, 0.000928793, 0, 0.00154799, 0, 0.000309597, 0.00247678, 0.0170279, 0.000309598, 0, 0.000309597, 0, 0.000309598, 0.000619195, 0.000309598, 0.000309597, 0.000309598, 0, 0.000309598, 0, 0.000309597, 0, 0.000309598, 0, 0, 0.000619195, 0, 0, 0.000619195, 0.000928793, 0.000309597, 0.000309598, 0, 0, 0, 0, 0.000309598, 0, 0.000928792, 0, 0.000309598, 0, 0.000309598, 0.000309598, 0.000309597, 0, 0, 0, 0.000309598, 0, 0, 0, 0.000928792, 0.000309598, 0, 0, 0.000309598, 0.000309598, 0, 0, 0, 0, 0, 0, 0, 0, 0.000309598, 0, 0, 0, 0.000309597, 0, 0, 0, 0, 0.000309598, 0, 0.000309597, 0, 0.000309598, 0, 0, 0.000309598, 0, 0, 0, 0.000309598, 0, 0, 0, 0, 0, 0, 0, 0.000309598, 0, 0, 0, 0, 0, 0.000309598, 0, 0, 0, 0.000309597, 0, 0, 0, 0, 0, 0, 0, 0, 0.000309598, 0, 0.000309598, 0, 0, 0.000309597, 0, 0, 0.000309598, 0, 0, 0.000309598, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000309598, 0, 0, 0, 0, 0, 0.000309598, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000309598, 0, 0, 0, 0, 0, 0.000619195, 0, 0, 0, 0, 0, 0, 0.000309598, 0, 0, 0.000309597, 0, 0, 0, 0, 0, 0, 0.000309598, 0, 0.000309598, 0, 0, 0, 0, 0, 0, 0.000309598, 0, 0, 0, 0, 0, 0, 0, 0.000309598, 0, 0, 0, 0, 0, 0, 0, 0, 0.000309598, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000309597, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000309598, 0, 0, 0, 0, 0, 0.000309598, 0, 0, 0, 0, 0, 0, 0.000309597, 0, 0, 0, 0, 0.000309598, 0, 0, 0.00216718, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000309598, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000309598, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000309598, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000309598, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000309598, 0, 0, 0, 0.000309597, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000309598, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000619195, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000309598, 0, 0.000309598, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000309597, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000309598};
 static constexpr double kMemcpyGoogleD[] = {0.0234987, 0.0137076, 0.0104439, 0.0117493, 0.022846, 0.017624, 0.0672324, 0.0372063, 0.0391645, 0.0372063, 0.0248042, 0.0456919, 0.0267624, 0.0359008, 0.0156658, 0.00522193, 0.0306789, 0.0124021, 0.0104439, 0.0137076, 0.00261097, 0.0150131, 0.0365535, 0.00391645, 0.00652742, 0.0443864, 0.0163185, 0.0430809, 0.00587467, 0.0169713, 0.0110966, 0.00130548, 0.0293734, 0, 0.000652742, 0.00195822, 0.0248042, 0.00391645, 0.00979112, 0.000652742, 0.0365535, 0.000652742, 0.00130548, 0.000652742, 0.000652742, 0.000652741, 0.00913838, 0, 0.000652742, 0, 0, 0.000652741, 0, 0, 0.00130548, 0, 0.0163185, 0.000652741, 0.000652742, 0.000652742, 0, 0, 0.000652742, 0, 0.00913838, 0.000652742, 0, 0, 0.000652741, 0, 0, 0, 0.00130548, 0, 0.000652742, 0, 0, 0.00130548, 0, 0, 0, 0, 0, 0, 0, 0.00261097, 0, 0.00913838, 0.0300261, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.00195822, 0, 0, 0.00130548, 0.000652742, 0.00456919, 0, 0, 0, 0, 0, 0, 0.00130548, 0.0130548, 0, 0, 0, 0, 0, 0.000652741, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.00261097, 0, 0, 0, 0, 0.000652742, 0, 0, 0.00326371, 0, 0.00130548, 0, 0, 0, 0.000652742, 0, 0.00130548, 0, 0, 0, 0, 0, 0, 0, 0.00130548, 0, 0, 0, 0, 0, 0.000652742, 0, 0.00195822, 0, 0.000652741, 0, 0, 0, 0, 0, 0.00130548, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000652742, 0, 0.000652741, 0, 0, 0, 0, 0, 0, 0, 0.00195822, 0, 0, 0, 0.000652741, 0, 0, 0, 0.000652742, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.00130548, 0, 0, 0, 0, 0, 0.000652741, 0, 0.000652742, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000652742, 0, 0, 0.000652741, 0, 0.000652742, 0, 0, 0, 0, 0, 0, 0.00326371, 0, 0, 0.000652742, 0.000652741, 0, 0, 0, 0, 0.000652742, 0, 0, 0, 0.000652741, 0, 0.000652742, 0.00195822, 0.00195822, 0, 0, 0, 0, 0, 0, 0, 0.00130548, 0, 0, 0, 0, 0, 0.000652741, 0.000652742, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000652741, 0, 0, 0, 0, 0, 0, 0, 0.00130548, 0, 0, 0, 0, 0, 0.000652742, 0.000652741, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000652742, 0, 0, 0.000652741, 0, 0, 0, 0, 0, 0, 0.000652742, 0.000652742, 0, 0, 0, 0, 0, 0, 0, 0.000652742, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000652741, 0.000652742, 0.000652741, 0, 0.00326371, 0, 0, 0, 0, 0, 0.00261097, 0.000652742, 0, 0, 0.000652742, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000652741, 0, 0, 0, 0.000652742, 0, 0, 0, 0, 0, 0, 0, 0.000652741, 0, 0.000652742, 0, 0.000652741, 0, 0.000652742, 0, 0.000652741, 0, 0.00130548, 0, 0.000652742, 0, 0.00130548, 0, 0.000652742, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000652742, 0, 0.00130548, 0, 0, 0, 0, 0, 0.000652741, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000652742, 0, 0, 0, 0, 0, 0.000652741, 0, 0, 0, 0, 0, 0.000652742, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000652741, 0, 0.000652742, 0, 0.00130548, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000652741, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000652742, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000652742, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000652742, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.00130548};
 static constexpr double kMemcpyGoogleL[] = {0.1405, 0.0487, 0, 0.0324, 0.0216, 0, 0.0379, 0, 0.027, 0.0054, 0, 0.2108, 0.0162, 0.0217, 0.0919, 0, 0.0432, 0.0919, 0, 0.0703, 0, 0, 0, 0.0973, 0, 0, 0, 0.0054, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0054, 0, 0.0108, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0054, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0054, 0, 0, 0, 0, 0, 0.0054, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0054};
 static constexpr double kMemcpyGoogleM[] = {0.0721535, 0.0325991, 0.068308, 0.0556539, 0.0563932, 0.0461322, 0.0532884, 0.0617689, 0.0828007, 0.0433771, 0.0594034, 0.0279377, 0.0207739, 0.0242924, 0.0185332, 0.0384378, 0.0360666, 0.0178533, 0.0215373, 0.0189424, 0.00918205, 0.00407135, 0.00558588, 0.0164542, 0.00517671, 0.00187243, 0.00539378, 0.00443405, 0.00281149, 0.0020793, 0.00188286, 0.00131771, 0.0237737, 0.00349755, 0.00316146, 0.000935628, 0.00276963, 0.0021735, 0.00301304, 0.000647972, 0.00162138, 0.000899166, 0.000446994, 0.000298311, 0.000419752, 0.000250476, 0.000173168, 0.000251647, 0.00166741, 0.000240198, 0.000212313, 0.000251685, 0.000494377, 0.000263776, 0.000282404, 0.000370745, 0.000823369, 0.000437322, 0.000194252, 0.00019667, 0.000828546, 0.000114224, 0.000515272, 0.000150837, 0.0101547, 8.00283e-05, 7.56452e-05, 8.59983e-05, 9.46888e-05, 6.64257e-05, 6.00779e-05, 0.000211406, 0.000262491, 5.85287e-05, 6.83906e-05, 6.7257e-05, 0.00014294, 6.28362e-05, 5.11607e-05, 4.88935e-05, 0.000250324, 5.18408e-05, 4.29614e-05, 9.52933e-05, 8.53938e-05, 4.32636e-05, 4.22434e-05, 3.61601e-05, 0.000140484, 3.77471e-05, 7.67788e-05, 3.37796e-05, 4.91958e-05, 5.22565e-05, 3.06813e-05, 4.11099e-05, 0.00285317, 2.89054e-05, 3.44598e-05, 2.82631e-05, 4.53418e-05, 2.21041e-05, 2.75451e-05, 2.1953e-05, 0.000106667, 2.45979e-05, 2.74318e-05, 2.0555e-05, 2.30487e-05, 2.49002e-05, 2.88298e-05, 2.31244e-05, 8.13507e-05, 3.09836e-05, 5.78108e-05, 5.58837e-05, 6.01913e-05, 4.32258e-05, 3.97119e-05, 3.91451e-05, 0.000372181, 1.63986e-05, 1.63608e-05, 1.20911e-05, 1.70788e-05, 1.63986e-05, 2.1953e-05, 1.25068e-05, 0.00486468, 9.7863e-06, 2.28976e-05, 1.33002e-05, 1.22045e-05, 1.71921e-05, 1.13355e-05, 0.000251571, 0.000526834, 9.7863e-06, 1.06175e-05, 1.36026e-05, 1.92702e-05, 1.36781e-05, 1.02775e-05, 1.00508e-05, 2.18774e-05, 1.76455e-05, 9.2951e-06, 1.55296e-05, 1.03908e-05, 9.7485e-06, 1.78722e-05, 8.7661e-06, 1.85901e-05, 1.03908e-05, 1.09954e-05, 1.47361e-05, 7.4058e-06, 7.8593e-06, 8.1993e-06, 1.34514e-05, 0.000588612, 9.6729e-06, 8.0482e-06, 9.0306e-06, 9.5218e-06, 1.60207e-05, 1.12599e-05, 9.3329e-06, 0.000758153, 1.00508e-05, 1.7381e-05, 1.4056e-05, 1.05419e-05, 7.4814e-06, 9.673e-06, 1.50005e-05, 1.4925e-05, 1.20912e-05, 9.7485e-06, 8.9928e-06, 1.63608e-05, 1.10332e-05, 1.14866e-05, 1.49627e-05, 1.46606e-05, 1.39804e-05, 9.7862e-06, 1.01264e-05, 9.7484e-06, 9.2951e-06, 1.31869e-05, 7.557e-06, 0.000428593, 7.3681e-06, 9.0683e-06, 1.99882e-05, 1.11088e-05, 5.3276e-06, 7.6326e-06, 5.2898e-06, 2.19152e-05, 5.4411e-06, 8.1993e-06, 4.9876e-06, 5.5543e-06, 1.21667e-05, 5.8189e-06, 5.8189e-06, 1.06931e-05, 2.9321e-05, 1.16755e-05, 5.7433e-06, 0.000636939, 5.4788e-06, 5.7811e-06, 0.000331675, 0.000737333, 5.1765e-06, 5.9322e-06, 6.499e-06, 0.000642644, 6.1211e-06, 4.0808e-06, 7.1791e-06, 0.000196405, 1.28469e-05, 6.1967e-06, 5.2143e-06, 0.000352004, 6.0078e-06, 1.75322e-05, 7.1035e-06, 8.6527e-06, 7.8593e-06, 2.34266e-05, 1.53406e-05, 1.37159e-05, 1.26957e-05, 1.35648e-05, 1.26579e-05, 0.000177513, 5.8189e-06, 4.1941e-06, 5.4032e-06, 4.8743e-06, 1.03908e-05, 4.6475e-06, 7.1792e-06, 5.441e-06, 3.2873e-06, 1.17133e-05, 3.2872e-06, 3.4385e-06, 5.2143e-06, 5.5543e-06, 1.27713e-05, 0.00346324};
 static constexpr double kMemcpyGoogleQ[] = {0.0178373, 0.114968, 0.0227802, 0.0150139, 0.188859, 0.00455751, 0.0233952, 0.0106787, 0.341347, 0.00630641, 0.050229, 0.00491322, 0.00606186, 0.00478724, 0.0110566, 0.00501697, 0.0128277, 0.00962636, 0.00522447, 0.0112196, 0.00589142, 0.00513554, 0.00491322, 0.00341628, 0.00472796, 0.00269004, 0.00394985, 0.00325325, 0.00183042, 0.00234916, 0.00129685, 0.00220095, 0.0034311, 0.0016822, 0.000837397, 0.00180818, 0.001119, 0.00357932, 0.0012598, 0.00108195, 0.00443894, 0.0013265, 0.00113382, 0.00103007, 0.000933735, 0.0016081, 0.00108195, 0.00116346, 0.000726238, 0.00250478, 0.00100043, 0.0010523, 0.00117087, 0.00113382, 0.000778112, 0.00108936, 0.001119, 0.00169703, 0.00145989, 0.000941145, 0.00181559, 0.000963377, 0.000637311, 0.000829986, 0.00169703, 0.00120793, 0.00138578, 0.00074847, 0.000792933, 0.000474278, 0.00075588, 0.000444636, 0.000704006, 0.000511331, 0.000437225, 0.000518741, 0.000333477, 0.000414993, 0.00037794, 0.00228246, 0.00904092, 0.000466867, 0.000259371, 0.000392761, 0.00025196, 0.000296424, 0.000289013, 0.000148212, 0.000852218, 0.000177854, 0.000103748, 0.000133391, 0.000192675, 0.000192675, 0.000185265, 0.000111159, 0.000407583, 0.000578026, 0.000111159, 0.00111159, 0.000118569, 0.000340887, 0.000177854, 0.000170444, 0.000133391, 0.000118569, 0.000155622, 8.89271e-05, 4.44635e-05, 7.41059e-05, 9.63377e-05, 5.92848e-05, 9.63376e-05, 0.000111159, 5.92847e-05, 0.00012598, 7.41059e-05, 5.18741e-05, 0.000155623, 3.70529e-05, 0.000177854, 0.000244549, 5.92847e-05, 5.92848e-05, 5.18741e-05, 0.000200086, 0.000103748, 2.22317e-05, 0.000555794, 2.96423e-05, 5.92848e-05, 5.18741e-05, 3.7053e-05, 3.70529e-05, 2.96424e-05, 2.22318e-05, 0.00012598, 2.96424e-05, 5.18741e-05, 2.22318e-05, 2.96423e-05, 5.18742e-05, 1.48212e-05, 2.96423e-05, 0.000140801, 2.96423e-05, 8.89271e-05, 7.41059e-05, 5.18742e-05, 7.41059e-05, 5.18741e-05, 7.4106e-06, 0.00037794, 4.44635e-05, 5.18742e-05, 5.18741e-05, 5.92847e-05, 4.44636e-05, 5.18741e-05, 2.22318e-05, 5.92847e-05, 2.96424e-05, 2.22317e-05, 4.44636e-05, 1.48212e-05, 3.70529e-05, 7.4106e-06, 5.18742e-05, 5.92847e-05, 3.70529e-05, 3.7053e-05, 2.96424e-05, 2.96423e-05, 5.18742e-05, 4.44635e-05, 2.96424e-05, 0.000274192, 7.41059e-05, 6.66953e-05, 6.66953e-05, 0.000140801, 5.18742e-05, 2.96424e-05, 7.41059e-05, 8.89271e-05, 5.18741e-05, 8.89271e-05, 6.66953e-05, 8.89271e-05, 0.000111159, 7.41059e-05, 3.70529e-05, 0.000185265, 8.89271e-05, 7.41059e-05, 5.92848e-05, 7.4106e-06, 5.92847e-05, 4.44635e-05, 4.44636e-05, 0.000155622, 6.66953e-05, 8.89271e-05, 3.7053e-05, 6.66953e-05, 4.44635e-05, 5.18742e-05, 2.22317e-05, 0.000155623, 5.18741e-05, 3.7053e-05, 7.41059e-05, 3.70529e-05, 8.15165e-05, 3.7053e-05, 1.48212e-05, 4.44635e-05, 3.7053e-05, 4.44635e-05, 4.44636e-05, 3.70529e-05, 6.66953e-05, 6.66954e-05, 2.22317e-05, 0.000155622, 5.92848e-05, 4.44635e-05, 6.66953e-05, 2.96424e-05, 2.96424e-05, 3.70529e-05, 2.96424e-05, 3.7053e-05, 5.18741e-05, 7.4106e-06, 2.22318e-05, 5.92847e-05, 2.96424e-05, 2.22317e-05, 2.22318e-05, 8.15165e-05, 1.48212e-05, 4.44635e-05, 2.22318e-05, 4.44636e-05, 2.22317e-05, 3.7053e-05, 2.22318e-05, 8.15165e-05, 3.70529e-05, 3.7053e-05, 5.92847e-05, 1.48212e-05, 1.48212e-05, 1.48211e-05, 1.48212e-05, 0.000207497, 3.70529e-05, 2.96424e-05, 3.7053e-05, 3.70529e-05, 1.48212e-05, 3.7053e-05, 1.48211e-05, 0.00012598, 2.96424e-05, 2.22317e-05, 2.96424e-05, 2.22318e-05, 2.96423e-05, 2.22318e-05, 2.96424e-05, 4.44635e-05, 2.22318e-05, 2.96424e-05, 3.70529e-05, 1.48212e-05, 2.22318e-05, 2.22317e-05, 2.96424e-05, 2.96424e-05, 2.96423e-05, 1.48212e-05, 2.22318e-05, 1.48212e-05, 1.48212e-05, 2.96423e-05, 1.48212e-05, 2.22318e-05, 1.48212e-05, 2.96423e-05, 1.48212e-05, 1.48212e-05, 1.48212e-05, 1.48212e-05, 7.4105e-06, 6.66954e-05, 1.48212e-05, 2.96423e-05, 2.96424e-05, 2.22318e-05, 1.48211e-05, 7.4106e-06, 7.4106e-06, 7.4106e-06, 0, 2.96424e-05, 0, 2.22317e-05, 2.22318e-05, 1.48212e-05, 2.22318e-05, 7.4106e-06, 1.48212e-05, 7.4105e-06, 2.22318e-05, 2.22318e-05, 2.22318e-05, 7.4106e-06, 2.96423e-05, 0.000207497, 7.4106e-06, 2.96423e-05, 7.4106e-06, 7.4106e-06, 7.4106e-06, 7.4106e-06, 1.48212e-05, 7.4106e-06, 1.48212e-05, 7.4105e-06, 5.18742e-05, 7.4106e-06, 1.48212e-05, 1.48211e-05, 1.48212e-05, 8.15165e-05, 0, 1.48212e-05, 7.4106e-06, 1.48212e-05, 0, 7.4106e-06, 1.48212e-05, 2.96423e-05, 7.4106e-06, 2.22318e-05, 2.22318e-05, 2.22317e-05, 7.4106e-06, 3.7053e-05, 2.22318e-05, 7.4105e-06, 7.4106e-06, 7.4106e-06, 1.48212e-05, 4.44636e-05, 2.22317e-05, 7.4106e-06, 1.48212e-05, 2.22318e-05, 2.22317e-05, 0, 1.48212e-05, 0, 2.96424e-05, 1.48212e-05, 7.4106e-06, 0.000118569, 2.96424e-05, 7.4106e-06, 1.48212e-05, 1.48212e-05, 2.22317e-05, 1.48212e-05, 7.4106e-06, 1.48212e-05, 1.48212e-05, 5.18741e-05, 7.4106e-06, 0, 0, 1.48212e-05, 2.22317e-05, 0.000185265, 0, 2.22318e-05, 0, 7.4106e-06, 0, 3.70529e-05, 0, 3.7053e-05, 0, 3.7053e-05, 0, 3.70529e-05, 0, 4.44636e-05, 0, 7.41059e-05, 0, 1.48212e-05, 0, 1.48211e-05, 0, 4.44636e-05, 0, 5.92847e-05, 0, 0, 0, 2.96424e-05, 0, 2.96423e-05, 0, 7.4106e-06, 0, 2.22318e-05, 0, 2.96424e-05, 0, 2.22318e-05, 0, 1.48211e-05, 0, 2.96424e-05, 0, 1.48212e-05, 0, 2.22318e-05, 0, 3.70529e-05, 0, 1.48212e-05, 0, 1.48212e-05, 0, 2.22318e-05, 0, 1.48211e-05, 0, 2.22318e-05, 0, 2.22318e-05, 0, 7.4106e-06, 0, 7.41059e-05, 0, 1.48212e-05, 0, 2.96423e-05, 0, 1.48212e-05, 0, 1.48212e-05, 0, 1.48212e-05, 0, 1.48212e-05, 0, 2.22317e-05, 0, 7.4106e-06, 0, 0, 0, 2.22318e-05, 0, 1.48212e-05, 0, 2.96423e-05, 0, 2.22318e-05, 0, 2.22318e-05, 0, 0, 0, 5.18741e-05, 0, 3.7053e-05, 0, 7.4106e-06, 0, 2.96423e-05, 0, 4.44636e-05, 0, 2.22318e-05, 0, 2.22317e-05, 0, 2.96424e-05, 0, 0.000207497, 0, 2.96423e-05, 0, 2.96424e-05, 0, 3.70529e-05, 0, 1.48212e-05, 0, 3.7053e-05, 0, 1.48212e-05, 0, 2.96423e-05, 0, 0.000155622, 0, 1.48212e-05, 0, 7.4106e-06, 0, 2.96424e-05, 0, 2.22318e-05, 0, 4.44635e-05, 0, 1.48212e-05, 0, 3.70529e-05, 0, 2.96424e-05, 0, 2.22318e-05, 0, 1.48212e-05, 0, 7.4106e-06, 0, 7.4105e-06, 0, 2.22318e-05, 0, 2.96424e-05, 0, 7.4106e-06, 0, 1.48212e-05, 0, 2.22317e-05, 0, 7.4106e-06, 0, 2.96424e-05, 0, 7.4106e-06, 0, 0, 0, 0, 0, 2.96423e-05, 0, 2.96424e-05, 0, 3.7053e-05, 0, 2.22317e-05, 0, 7.4106e-06, 0, 8.89271e-05, 0, 0, 0, 7.4106e-06, 0, 2.96424e-05, 0, 5.92847e-05, 0, 1.48212e-05, 0, 2.96424e-05, 0, 7.4105e-06, 0, 2.22318e-05, 0, 1.48212e-05, 0, 2.96424e-05, 0, 0, 0, 1.48212e-05, 0, 2.22317e-05, 0, 1.48212e-05, 0, 7.4106e-06};
 static constexpr double kMemcpyGoogleS[] = {0.0184049, 0.0306748, 0.00613497, 0.0122699, 0.0306748, 0.0122699, 0.0245399, 0.0245399, 0.00613497, 0.0122699, 0.00613497, 0.0122699, 0.0490798, 0.0920245, 0.0122699, 0, 0.0122699, 0.00613497, 0.147239, 0.239264, 0.00613497, 0.0184049, 0.0245399, 0, 0.0122699, 0.00613497, 0.00613497, 0.0122699, 0.00613497, 0, 0, 0.00613497, 0, 0, 0, 0.00613497, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.00613497, 0, 0.00613497, 0, 0, 0, 0, 0, 0, 0, 0, 0.0184049, 0, 0, 0.00613497, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.00613497, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0122699, 0, 0.00613497, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.00613497, 0, 0, 0, 0, 0, 0, 0.00613497, 0.00613497, 0, 0.0122699, 0.0122699, 0, 0, 0, 0, 0.00613497, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.00613497, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.00613497, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.00613497, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.00613497, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.00613497};
 static constexpr double kMemcpyGoogleU[] = {0.0177, 0.2767, 0.0548, 0.011, 0.0156, 0.1325, 0.0614, 0.0195, 0.1576, 0.0099, 0.0066, 0.0083, 0.0066, 0.0087, 0.0054, 0.0051, 0.0243, 0.0059, 0.0124, 0.0062, 0.0045, 0.0055, 0.0061, 0.0044, 0.0121, 0.0028, 0.0038, 0.0031, 0.0033, 0.0028, 0.0028, 0.0026, 0.0109, 0.0019, 0.0013, 0.0013, 0.0008, 0.001, 0.0009, 0.0011, 0.0003, 0.0094, 0.0003, 0.0008, 0.0004, 0.0003, 0.0008, 0.0014, 0.0007, 0.0004, 0.0001, 0.0003, 0.0002, 0.0004, 0.0002, 0.0003, 0.0003, 0.0002, 0.0003, 0.0002, 0.0002, 0.0003, 0.0001, 0.0002, 0.0097, 0.0002, 0.0001, 0.0001, 0.0003, 0.0001, 0.0001, 0.0001, 0.0002, 0.0001, 0.0001, 0.0001, 0.0002, 0.0001, 0.0001, 0.0001, 0.0002, 0.0002, 0, 0.0001, 0.0001, 0.0001, 0.0001, 0.0001, 0.0004, 0, 0.0002, 0.0002, 0.0002, 0.0001, 0.0002, 0.0001, 0.0005, 0, 0.0001, 0.0001, 0.0002, 0.0001, 0.0001, 0, 0.0002, 0.0001, 0.0001, 0.0001, 0.0001, 0.0001, 0.0001, 0.0001, 0.0002, 0.0002, 0.0001, 0.0001, 0.0014, 0.0001, 0.0001, 0.0001, 0.0001, 0.0001, 0.0001, 0.0001, 0, 0.0001, 0.0001, 0, 0.0033, 0, 0, 0.0004, 0.0001, 0.0001, 0, 0, 0.0002, 0.0001, 0, 0, 0.0001, 0.0001, 0, 0, 0.0011, 0, 0.0001, 0, 0, 0.0001, 0, 0, 0.0001, 0, 0, 0.0001, 0, 0, 0, 0, 0.0001, 0, 0, 0.0001, 0, 0, 0, 0.0001, 0, 0, 0.0001, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0.0001, 0, 0, 0.0001, 0.0001, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0.0001, 0.0001, 0, 0, 0.0001, 0.0045, 0, 0, 0.0001, 0, 0, 0.0001, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0.0003, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0048, 0, 0, 0, 0, 0, 0, 0, 0.0002, 0, 0, 0, 0, 0, 0.0001, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0013, 0.0001, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0.0005, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0.0001};
 static constexpr double kMemcpyGoogleW[] = {0.0199353, 0, 0.0245151, 0, 0.102101, 0, 0.0301724, 0, 0.0347522, 0, 0.0309806, 0, 0.0242457, 0, 0.0239763, 0, 0.0360991, 0, 0.0358297, 0, 0.03125, 0, 0.0188578, 0, 0.0261315, 0, 0.028556, 0, 0.00942888, 0, 0.0118534, 0, 0.0282866, 0, 0.0172414, 0, 0.0180496, 0, 0.0185884, 0, 0.012931, 0, 0.0145474, 0, 0.00915948, 0, 0.0107759, 0, 0.0153556, 0, 0.0115841, 0, 0.00969828, 0, 0.0123922, 0, 0.0105065, 0, 0.00996767, 0, 0.0121228, 0, 0.0107759, 0, 0.0307112, 0, 0.0102371, 0, 0.00727371, 0, 0.0113147, 0, 0.00889009, 0, 0.00915948, 0, 0.00835129, 0, 0.00915948, 0, 0.0105065, 0, 0.00484914, 0, 0.00835129, 0, 0.00538793, 0, 0.00996767, 0, 0.00538793, 0, 0.00862069, 0, 0.00511853, 0, 0.00592672, 0, 0.00565733, 0, 0.00511853, 0, 0.0080819, 0, 0.00377155, 0, 0.00404095, 0, 0.00511853, 0, 0.00457974, 0, 0.00431034, 0, 0.00296336, 0, 0.00242457, 0, 0.00404095, 0, 0.00565733, 0, 0.00188578, 0, 0.00215517, 0, 0.00242457, 0, 0.0080819, 0, 0.00080819, 0, 0.00080819, 0, 0.000269397, 0, 0.00188578, 0, 0.00161638, 0, 0, 0, 0.000269397, 0, 0.00269397, 0, 0.00107759, 0, 0, 0, 0.000269397, 0, 0.000538793, 0, 0, 0, 0.000269397, 0, 0.00134698, 0, 0.00134698, 0, 0.000538793, 0, 0.000269397, 0, 0.000269397, 0, 0, 0, 0, 0, 0, 0, 0.000538793, 0, 0.00215517, 0, 0.00080819, 0, 0.000269397, 0, 0.000269397, 0, 0.000538793, 0, 0.000538793, 0, 0.00107759, 0, 0.00161638, 0, 0.00134698, 0, 0.00296336, 0, 0.000538793, 0, 0.000269397, 0, 0.000269397, 0, 0.00134698, 0, 0, 0, 0.00107759, 0, 0.00161638, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000269397, 0, 0.00080819, 0, 0.000269397, 0, 0.00080819, 0, 0, 0, 0.000269397, 0, 0.000269397, 0, 0, 0, 0, 0, 0.00161638, 0, 0.000269397, 0, 0.000269397, 0, 0, 0, 0.000538793, 0, 0, 0, 0, 0, 0, 0, 0.00404095, 0, 0, 0, 0.000269397, 0, 0.000269397, 0, 0, 0, 0.000269397, 0, 0.000269397, 0, 0.000269396, 0, 0.000538793, 0, 0.000269397, 0, 0.000538793, 0, 0.000269397, 0, 0, 0, 0.000538793, 0, 0.000269397, 0, 0, 0, 0.000538793, 0, 0.000269397, 0, 0, 0, 0, 0, 0, 0, 0.000269397, 0, 0.000269397, 0, 0.000269396, 0, 0.00080819, 0, 0.000269397, 0, 0.000538793, 0, 0, 0, 0.000269397, 0, 0.000269397, 0, 0.000538793, 0, 0.000269397, 0, 0.000538793, 0, 0, 0, 0, 0, 0.000269396, 0, 0, 0, 0.000269397, 0, 0.000269397, 0, 0, 0, 0.000269397, 0, 0.000269397, 0, 0.000269397, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000269397, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000269397, 0, 0.000269397, 0, 0, 0, 0.000269397, 0, 0, 0, 0, 0, 0, 0, 0.000269397, 0, 0, 0, 0, 0, 0.000269397, 0, 0.000269397, 0, 0.000269397, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000269397, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000269396, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000538793, 0, 0, 0, 0.000269397, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.000269397, 0, 0, 0, 0.000269397, 0, 0.000269397, 0, 0, 0, 0.000269397, 0, 0.000269397, 0, 0.000269397, 0, 0, 0, 0, 0, 0, 0, 0.000269397, 0, 0, 0, 0.000269397, 0, 0, 0, 0, 0, 0, 0, 0.000269397, 0, 0, 0, 0, 0, 0.000269397, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.00215517};
+static constexpr double kMemcpyUniform384To4096[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
 static constexpr double kMemsetGoogleB[] = {0, 0, 0, 0, 0, 0, 0, 0, 0.0681818, 0, 0, 0, 0, 0, 0.5, 0, 0.0227273, 0, 0, 0, 0, 0, 0.0227273, 0, 0.0454545, 0.0227273, 0, 0, 0, 0, 0, 0.0227273, 0.0227273, 0, 0, 0, 0, 0, 0, 0.0227273, 0.0227273, 0, 0, 0, 0, 0, 0, 0, 0.0454545, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0227273, 0, 0, 0, 0, 0, 0, 0, 0.0227273, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0681818, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0227273, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0227273, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0227273};
 static constexpr double kMemsetGoogleD[] = {0.0243902, 0, 0, 0, 0, 0, 0, 0, 0.0487805, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0243902, 0, 0, 0, 0, 0, 0, 0.0609756, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0121951, 0, 0, 0, 0.0121951, 0, 0, 0, 0.0365854, 0, 0, 0, 0, 0, 0, 0, 0.0121951, 0, 0, 0, 0, 0, 0, 0, 0.0609756, 0, 0, 0, 0, 0, 0, 0, 0.0243902, 0, 0, 0, 0, 0, 0, 0, 0.0121951, 0, 0, 0, 0, 0, 0, 0, 0.0609756, 0, 0, 0, 0, 0, 0, 0, 0.0487805, 0, 0, 0, 0, 0, 0, 0, 0.0243902, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0853659, 0, 0, 0, 0, 0, 0, 0, 0.0487805, 0, 0, 0, 0, 0, 0, 0, 0.0121951, 0, 0, 0, 0, 0, 0, 0, 0.0853659, 0, 0, 0, 0, 0, 0, 0, 0.0731707, 0, 0, 0, 0, 0, 0, 0, 0.0365854, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0121951, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0243902, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0365854, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0121951, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0121951, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0121951, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0121951, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0365854, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0365854};
 static constexpr double kMemsetGoogleQ[] = {0, 0, 0.0043, 0.0055, 0.0033, 0.0025, 0.0037, 0.0026, 0.0038, 0.0024, 0.0023, 0.003, 0.0025, 0.0008, 0.001, 0.0012, 0.0035, 0.0013, 0.001, 0.0002, 0.0004, 0.0009, 0.0011, 0.0007, 0.0008, 0.0014, 0.001, 0.0005, 0.0006, 0, 0.0007, 0.0021, 0.2082, 0.0013, 0.0004, 0.0003, 0.0005, 0.0005, 0.0008, 0.0003, 0.0005, 0.0007, 0.0002, 0.0001, 0.0007, 0.0005, 0.0005, 0.001, 0.0007, 0, 0.0005, 0.0001, 0.0002, 0, 0.0003, 0.0004, 0.0543, 0, 0.0005, 0.0003, 0.0003, 0.0004, 0.0001, 0, 0.0602, 0.0001, 0.0002, 0, 0, 0, 0.0003, 0.0004, 0.1578, 0, 0.0003, 0.0002, 0.001, 0, 0, 0.0013, 0.1236, 0, 0.0001, 0.0002, 0.0028, 0.0002, 0, 0.0002, 0.033, 0.0002, 0, 0, 0.0002, 0.0001, 0.0002, 0, 0.0129, 0.0002, 0.0002, 0.0003, 0.0018, 0, 0, 0.0002, 0.0126, 0.0002, 0.0002, 0.0003, 0.0007, 0.0001, 0, 0.0004, 0.0166, 0, 0.0001, 0, 0.0014, 0.0001, 0, 0, 0.0002, 0, 0, 0, 0.002, 0.0066, 0, 0, 0, 0, 0, 0, 0.0005, 0, 0, 0, 0.0002, 0, 0, 0, 0.0005, 0, 0, 0.0005, 0.0002, 0, 0, 0, 0, 0, 0, 0, 0.0003, 0, 0, 0, 0.0013, 0, 0, 0, 0.0023, 0, 0, 0, 0.0017, 0, 0, 0, 0, 0, 0, 0, 0.0017, 0, 0, 0, 0.0064, 0, 0, 0, 0, 0, 0, 0, 0.0009, 0, 0, 0, 0.0005, 0, 0, 0, 0.0702, 0, 0, 0, 0.0015, 0, 0, 0, 0.0017, 0, 0, 0, 0.0018, 0, 0, 0, 0.0002, 0, 0, 0, 0.0028, 0, 0, 0, 0.003, 0, 0, 0, 0, 0, 0, 0, 0.0121, 0, 0, 0, 0, 0, 0, 0, 0.0039, 0, 0, 0, 0.0021, 0, 0, 0, 0.0005, 0, 0, 0, 0.0037, 0, 0, 0, 0.0045, 0, 0, 0, 0.0019, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0014, 0, 0, 0, 0, 0, 0, 0.0163, 0.0011, 0, 0, 0, 0.0037, 0, 0, 0, 0.0006, 0, 0, 0, 0.0005, 0, 0, 0, 0.0015, 0, 0, 0, 0.0014, 0, 0, 0, 0.0044, 0, 0, 0, 0.002, 0, 0, 0, 0.0027, 0, 0, 0, 0, 0, 0, 0, 0.001, 0, 0, 0, 0, 0, 0, 0, 0.0026, 0, 0, 0, 0.0004, 0, 0, 0, 0.0023, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0003, 0, 0, 0, 0.0002, 0, 0, 0, 0.0028, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0009, 0, 0, 0, 0.0006, 0, 0, 0, 0, 0, 0, 0, 0.0002, 0, 0, 0, 0, 0, 0, 0, 0.0012, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0003, 0, 0, 0, 0, 0, 0, 0, 0.0008, 0, 0, 0, 0, 0, 0, 0, 0.0015, 0, 0, 0, 0.002, 0, 0, 0, 0.0007, 0, 0, 0, 0, 0, 0, 0, 0.0016, 0, 0, 0, 0, 0, 0, 0, 0.0009, 0, 0, 0, 0, 0, 0, 0, 0.001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0019, 0, 0, 0, 0, 0, 0, 0, 0.0007, 0, 0, 0, 0, 0, 0, 0, 0.0002, 0, 0, 0, 0.0286, 0, 0, 0, 0.0006, 0, 0, 0, 0, 0, 0, 0, 0.0007, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0.0002, 0, 0, 0, 0, 0, 0, 0, 0.0022, 0, 0, 0, 0, 0, 0, 0, 0.0038, 0, 0, 0, 0.0003, 0, 0, 0, 0.0004, 0, 0, 0, 0, 0, 0, 0, 0.0006, 0, 0, 0, 0, 0, 0, 0, 0.0009, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0.001, 0, 0, 0, 0, 0, 0, 0, 0.0002, 0, 0, 0, 0.0005, 0, 0, 0, 0.001, 0, 0, 0, 0.0018, 0, 0, 0, 0, 0, 0, 0, 0.0005, 0, 0, 0, 0, 0, 0, 0, 0.0002, 0, 0, 0, 0, 0, 0, 0, 0.0003};
 static constexpr double kMemsetGoogleU[] = {0.1064, 0.0986, 0.0201, 0.0042, 0.1506, 0.0276, 0.0028, 0.0033, 0.3233, 0.1282, 0.011, 0.0035, 0.0015, 0.0019, 0.0005, 0.0007, 0.0143, 0.0152, 0.0005, 0.0146, 0.0013, 0.0001, 0.0001, 0.0067, 0.0054, 0, 0.0001, 0, 0.0006, 0, 0.0002, 0.0062, 0.0005, 0, 0, 0, 0.0004, 0, 0, 0.0001, 0.0003, 0, 0.0001, 0, 0.0001, 0.0001, 0, 0.0021, 0.0002, 0, 0, 0.0001, 0.0001, 0.0001, 0, 0, 0.0001, 0.0001, 0, 0.0001, 0.0001, 0, 0.0001, 0, 0.0092, 0, 0, 0, 0.0002, 0, 0, 0, 0.007, 0, 0, 0, 0, 0, 0, 0.0015, 0.0001, 0.0001, 0, 0, 0.0001, 0, 0, 0, 0.0001, 0, 0, 0.0001, 0, 0, 0, 0.0001, 0.0001, 0, 0, 0.0001, 0, 0, 0, 0, 0.0001, 0.0001, 0.0053, 0, 0.0001, 0, 0, 0, 0.0002, 0, 0, 0, 0.0001, 0, 0, 0.0001, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0.0001, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0.0001, 0, 0.0012, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0003, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0002, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0.0006, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0136, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0002, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0.0002, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0.0002, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.0001};
 // clang-format on
 
 ArrayRef<MemorySizeDistribution> getMemcpySizeDistributions() {
   static constexpr MemorySizeDistribution kDistributions[] = {
-      {"memcpy Google A", kMemcpyGoogleA}, {"memcpy Google B", kMemcpyGoogleB},
-      {"memcpy Google D", kMemcpyGoogleD}, {"memcpy Google L", kMemcpyGoogleL},
-      {"memcpy Google M", kMemcpyGoogleM}, {"memcpy Google Q", kMemcpyGoogleQ},
-      {"memcpy Google S", kMemcpyGoogleS}, {"memcpy Google U", kMemcpyGoogleU},
+      {"memcpy Google A", kMemcpyGoogleA},
+      {"memcpy Google B", kMemcpyGoogleB},
+      {"memcpy Google D", kMemcpyGoogleD},
+      {"memcpy Google L", kMemcpyGoogleL},
+      {"memcpy Google M", kMemcpyGoogleM},
+      {"memcpy Google Q", kMemcpyGoogleQ},
+      {"memcpy Google S", kMemcpyGoogleS},
+      {"memcpy Google U", kMemcpyGoogleU},
       {"memcpy Google W", kMemcpyGoogleW},
+      {"uniform 384 to 4096", kMemcpyUniform384To4096},
   };
   return kDistributions;
 }
 
 ArrayRef<MemorySizeDistribution> getMemsetSizeDistributions() {
   static constexpr MemorySizeDistribution kDistributions[] = {
       {"memset Google B", kMemsetGoogleB},
       {"memset Google D", kMemsetGoogleD},

libc/benchmarks/Memset.cpp

-//===-- Benchmark memset implementation -----------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include "LibcBenchmark.h"
-#include "LibcMemoryBenchmark.h"
-#include "LibcMemoryBenchmarkMain.h"
-#include "llvm/ADT/StringSwitch.h"
-#include "llvm/Support/raw_ostream.h"
-
-namespace __llvm_libc {
-void *memset(void *, int, size_t);
-} // namespace __llvm_libc
-
-namespace llvm {
-namespace libc_benchmarks {
-
-// The context encapsulates the buffers, parameters and the measure.
-struct MemsetContext : public BenchmarkRunner {
-  using FunctionPrototype = void *(*)(void *, int, size_t);
-
-  struct ParameterType {
-    uint16_t DstOffset = 0;
-  };
-
-  explicit MemsetContext(const StudyConfiguration &Conf)
-      : OD(Conf), DstBuffer(Conf.BufferSize), MemsetValue(Conf.MemsetValue),
-        PP(*this) {}
-
-  // Needed by the ParameterProvider to update the current batch of parameter.
-  void Randomize(MutableArrayRef<ParameterType> Parameters) {
-    for (auto &P : Parameters) {
-      P.DstOffset = OD(Gen);
-    }
-  }
-
-  ArrayRef<StringRef> getFunctionNames() const override {
-    static std::array<StringRef, 1> kFunctionNames = {"memset"};
-    return kFunctionNames;
-  }
-
-  BenchmarkResult benchmark(const BenchmarkOptions &Options,
-                            StringRef FunctionName, size_t Size) override {
-    FunctionPrototype Function = StringSwitch<FunctionPrototype>(FunctionName)
-                                     .Case("memset", &__llvm_libc::memset);
-    return llvm::libc_benchmarks::benchmark(
-        Options, PP, [this, Function, Size](ParameterType p) {
-          Function(DstBuffer + p.DstOffset, MemsetValue, Size);
-          return DstBuffer + p.DstOffset;
-        });
-  }
-
-private:
-  std::default_random_engine Gen;
-  OffsetDistribution OD;
-  AlignedBuffer DstBuffer;
-  const uint8_t MemsetValue;
-  SmallParameterProvider<MemsetContext> PP;
-};
-
-std::unique_ptr<BenchmarkRunner> getRunner(const StudyConfiguration &Conf) {
-  return std::make_unique<MemsetContext>(Conf);
-}
-
-} // namespace libc_benchmarks
-} // namespace llvm

libc/benchmarks/RATIONALE.md

 Benchmarking is a [subtle
 art](https://en.wikipedia.org/wiki/Benchmark_\(computing\)#Challenges) and
 benchmarking memory functions is no exception. Here we'll dive into
 peculiarities of designing good microbenchmarks for `llvm-libc` memory
 functions.
 
 ## Challenges
 
-As seen in the [README.md](README.md#benchmarking-regimes) the microbenchmarking
+As seen in the [README.md](README.md#stochastic-mode) the microbenchmarking
 facility should focus on measuring **low latency code**. If copying a few bytes
 takes in the order of a few cycles, the benchmark should be able to **measure
 accurately down to the cycle**.
 
 ### Measuring instruments
 
 There are different sources of time in a computer (ordered from high to low resolution)
  - [Performance

 Although they have the same name, the exact semantics of performance counters
 are micro-architecture dependent: **it is generally not possible to compare two
 micro-architectures exposing the same performance counters.**
 
 Each vendor decides which performance counters to implement and their exact
 meaning. Although we want to benchmark `llvm-libc` memory functions for all
 available [target
 triples](https://clang.llvm.org/docs/CrossCompilation.html#target-triple), there
-are **no guarantees that the counter we're interested in is available.** 
+are **no guarantees that the counter we're interested in is available.**
 
 ### Additional imprecisions
 
 -   Reading performance counters is done through Kernel [System
     calls](https://en.wikipedia.org/wiki/System_call). The System call itself
     is costly (hundreds of cycles) and will perturbate the counter's value.
 -   [Interruptions](https://en.wikipedia.org/wiki/Interrupt#Processor_response)
     can occur during measurement.

libc/benchmarks/README.md

 # Libc mem* benchmarks
 
-This framework has been designed to evaluate and compare relative performance of
-memory function implementations on a particular host.
+This framework has been designed to evaluate and compare relative performance of memory function implementations on a particular machine.
 
-It will also be use to track implementations performances over time.
+It relies on two tools:
+ - `libc-benchmark-main` a C++ benchmarking utility producing raw measurements,
+ - `libc-benchmark-analysis.py3` a tool to process the measurements into reports.
 
-## Quick start
+## Benchmarking tool
 
 ### Setup
 
-**Python 2** [being deprecated](https://www.python.org/doc/sunset-python-2/) it is
-advised to used **Python 3**.
-
-Then make sure to have `matplotlib`, `scipy` and `numpy` setup correctly:
-
 ```shell
-apt-get install python3-pip
-pip3 install matplotlib scipy numpy
+cd llvm-project
+cmake -B/tmp/build -Sllvm -DLLVM_ENABLE_PROJECTS='clang;clang-tools-extra;libc' -DCMAKE_BUILD_TYPE=Release -G Ninja
+ninja -C /tmp/build libc-benchmark-main
 ```
-You may need `python3-gtk` or similar package for displaying benchmark results.
-
-To get good reproducibility it is important to make sure that the system runs in
-`performance` mode. This is achieved by running:
 
+> Note: The machine should run in `performance` mode. This is achieved by running:
 ```shell
 cpupower frequency-set --governor performance
 ```
 
-### Run and display `memcpy` benchmark
+### Usage
 
-The following commands will run the benchmark and display a 95 percentile
-confidence interval curve of **time per copied bytes**. It also features **host
-informations** and **benchmarking configuration**.
+`libc-benchmark-main` can run in two modes:
+ - **stochastic mode** returns the average time per call for a particular size distribution,
+ - **sweep mode** returns the average time per size over a range of sizes.
 
-```shell
-cd llvm-project
-cmake -B/tmp/build -Sllvm -DLLVM_ENABLE_PROJECTS='clang;clang-tools-extra;libc' -DCMAKE_BUILD_TYPE=Release -G Ninja
-ninja -C /tmp/build display-libc-memcpy-benchmark-small
-```
+The tool requires the following flags to be set:
+ - `--study-name`: a name to identify a run and provide label during analysis,
+ - `--function`: the name of the function under test.
 
-The display target will attempt to open a window on the machine where you're
-running the benchmark. If this may not work for you then you may want `render`
-or `run` instead as detailed below.
+It also provides optional flags:
+ - `--num-trials`: repeats the benchmark more times, the analysis tool can take this into account and give confidence intervals.
+ - `--output`: specifies a file to write the report - or standard output if not set.
+ - `--aligned-access`: The alignment to use when accessing the buffers, default is unaligned, 0 disables address randomization.
 
-## Benchmarking targets
+> Note: `--function` takes a generic function name like `memcpy` or `memset` but the actual function being tested is the llvm-libc implementation (e.g. `__llvm_libc::memcpy`).
 
-The benchmarking process occurs in two steps:
+### Stochastic mode
 
-1. Benchmark the functions and produce a `json` file
-2. Display (or renders) the `json` file
+This is the preferred mode to use. The function parameters are randomized and the branch predictor is less likely to kick in.
 
-Targets are of the form `<action>-libc-<function>-benchmark-<configuration>`
+```shell
+/tmp/build/bin/libc-benchmark-main \
+    --study-name="new memcpy" \
+    --function=memcpy \
+    --size-distribution-name="memcpy Google A" \
+    --num-trials=30 \
+    --output=/tmp/benchmark_result.json
+```
 
- - `action` is one of :
-    - `run`, runs the benchmark and writes the `json` file
-    - `display`, displays the graph on screen
-    - `render`, renders the graph on disk as a `png` file
- - `function` is one of : `memcpy`, `memcmp`, `memset`
- - `configuration` is one of : `small`, `big`
+The `--size-distribution-name` flag is mandatory and points to one of the [predefined distribution](libc/benchmarks/MemorySizeDistributions.h).
 
-## Benchmarking regimes
+> Note: These distributions are gathered from several important binaries at Google (servers, databases, realtime and batch jobs) and reflect the importance of focusing on small sizes.
 
 Using a profiler to observe size distributions for calls into libc functions, it
 was found most operations act on a small number of bytes.
 
 Function           | % of calls with size ≤ 128 | % of calls with size ≤ 1024
 ------------------ | --------------------------: | ---------------------------:
 memcpy             | 96%                         | 99%
 memset             | 91%                         | 99.9%
 memcmp<sup>1</sup> | 99.5%                       | ~100%
 
-Benchmarking configurations come in two flavors:
-
- - [small](libc/utils/benchmarks/configuration_small.json)
-    - Exercises sizes up to `1KiB`, representative of normal usage
-    - The data is kept in the `L1` cache to prevent measuring the memory
-      subsystem
- - [big](libc/utils/benchmarks/configuration_big.json)
-    - Exercises sizes up to `32MiB` to test large operations
-    - Caching effects can show up here which prevents comparing different hosts
-
 _<sup>1</sup> - The size refers to the size of the buffers to compare and not
 the number of bytes until the first difference._
 
-## Superposing curves
+### Sweep mode
+
+This mode is used to measure call latency per size for a certain range of sizes. Because it exercises the same size over and over again the branch predictor can kick in. It can still be useful to compare strength and weaknesses of particular implementations.
+
+```shell
+/tmp/build/bin/libc-benchmark-main \
+    --study-name="new memcpy" \
+    --function=memcpy \
+    --sweep-mode \
+    --sweep-max-size=128 \
+    --output=/tmp/benchmark_result.json
+```
+
+## Analysis tool
 
-It is possible to **merge** several `json` files into a single graph. This is
-useful to **compare** implementations.
+### Setup
+
+Make sure to have `matplotlib`, `pandas` and `seaborn` setup correctly:
+
+```shell
+apt-get install python3-pip
+pip3 install matplotlib pandas seaborn
+```
+You may need `python3-gtk` or similar package to display the graphs.
 
-In the following example we superpose the curves for `memcpy`, `memset` and
-`memcmp`:
+### Usage
 
 ```shell
-> make -C /tmp/build run-libc-memcpy-benchmark-small run-libc-memcmp-benchmark-small run-libc-memset-benchmark-small
-> python libc/utils/benchmarks/render.py3 /tmp/last-libc-memcpy-benchmark-small.json /tmp/last-libc-memcmp-benchmark-small.json /tmp/last-libc-memset-benchmark-small.json
+python3 libc/benchmarks/libc-benchmark-analysis.py3 /tmp/benchmark_result.json ...
 ```
 
-## Useful `render.py3` flags
+When used with __multiple trials Sweep Mode data__ the tool displays the 95% confidence interval.
 
- - To save the produced graph `--output=/tmp/benchmark_curve.png`.
- - To prevent the graph from appearing on the screen `--headless`.
+When providing with multiple reports at the same time, all the graphs from the same machine are displayed side by side to allow for comparison.
 
+The Y-axis unit can be changed via the `--mode` flag:
+ - `time` displays the measured time (this is the default),
+ - `cycles` displays the number of cycles computed from the cpu frequency,
+ - `bytespercycle` displays the number of bytes per cycle (for `Sweep Mode` reports only).
 
 ## Under the hood
 
  To learn more about the design decisions behind the benchmarking framework,
  have a look at the [RATIONALE.md](RATIONALE.md) file.

libc/benchmarks/configuration_big.json

-{
-   "Options":{
-      "MinDuration":0.001,
-      "MaxDuration":1,
-      "InitialIterations":100,
-      "MaxIterations":10000000,
-      "MinSamples":1,
-      "MaxSamples":1,
-      "Epsilon":0.01,
-      "ScalingFactor":1.4
-   },
-   "Configuration":{
-      "Runs":5,
-      "BufferSize":134217728,
-      "Size":{
-        "From":0,
-        "To":33554432,
-        "Step":1048576
-      },
-      "AddressAlignment":1,
-      "MemsetValue":0,
-      "MemcmpMismatchAt":0
-   }
-}

libc/benchmarks/configuration_small.json

-{
-   "Options":{
-      "MinDuration":0.001,
-      "MaxDuration":1,
-      "InitialIterations":100,
-      "MaxIterations":10000000,
-      "MinSamples":4,
-      "MaxSamples":1000,
-      "Epsilon":0.01,
-      "ScalingFactor":1.4
-   },
-   "Configuration":{
-      "Runs":10,
-      "BufferSize":8192,
-      "Size":{
-        "From":0,
-        "To":1024,
-        "Step":1
-      },
-      "AddressAlignment":1,
-      "MemsetValue":0,
-      "MemcmpMismatchAt":0
-   }
-}

libc/benchmarks/libc-benchmark-analysis.py3

+"""Reads JSON files produced by the benchmarking framework and renders them.
+
+Installation:
+> apt-get install python3-pip
+> pip3 install matplotlib pandas seaborn
+
+Run:
+> python3 libc/benchmarks/libc-benchmark-analysis.py3 <files>
+"""
+
+import argparse
+import json
+import pandas as pd
+import seaborn as sns
+import matplotlib.pyplot as plt
+from matplotlib.ticker import EngFormatter
+
+def formatUnit(value, unit):
+    return EngFormatter(unit, sep="").format_data(value)
+
+def formatCache(cache):
+  letter = cache["Type"][0].lower()
+  level = cache["Level"]
+  size = formatUnit(cache["Size"], "B")
+  ways = cache["NumSharing"]
+  return F'{letter}L{level}:{size}/{ways}'
+
+def getCpuFrequency(study):
+    return study["Runtime"]["Host"]["CpuFrequency"]
+
+def getId(study):
+    CpuName = study["Runtime"]["Host"]["CpuName"]
+    CpuFrequency = formatUnit(getCpuFrequency(study), "Hz")
+    Mode = " (Sweep)" if study["Configuration"]["IsSweepMode"] else ""
+    CpuCaches = ", ".join(formatCache(c) for c in study["Runtime"]["Host"]["Caches"])
+    return F'{CpuName} {CpuFrequency}{Mode}\n{CpuCaches}'
+
+def getFunction(study):
+    return study["Configuration"]["Function"]
+
+def getLabel(study):
+    return F'{getFunction(study)} {study["StudyName"]}'
+
+def displaySweepData(id, studies, mode):
+    df = None
+    for study in studies:
+        Measurements = study["Measurements"]
+        SweepModeMaxSize = study["Configuration"]["SweepModeMaxSize"]
+        NumSizes = SweepModeMaxSize + 1
+        NumTrials = study["Configuration"]["NumTrials"]
+        assert NumTrials * NumSizes  == len(Measurements), 'not a multiple of NumSizes'
+        Index = pd.MultiIndex.from_product([range(NumSizes), range(NumTrials)], names=['size', 'trial'])
+        if df is None:
+            df = pd.DataFrame(Measurements, index=Index, columns=[getLabel(study)])
+        else:
+            df[getLabel(study)] = pd.Series(Measurements, index=Index)
+    df = df.reset_index(level='trial', drop=True)
+    if mode == "cycles":
+        df *= getCpuFrequency(study)
+    if mode == "bytespercycle":
+        df *= getCpuFrequency(study)
+        for col in df.columns:
+            df[col] = pd.Series(data=df.index, index=df.index).divide(df[col])
+    FormatterUnit = {"time":"s","cycles":"","bytespercycle":"B/cycle"}[mode]
+    Label = {"time":"Time","cycles":"Cycles","bytespercycle":"Byte/cycle"}[mode]
+    graph = sns.lineplot(data=df, palette="muted", ci=95)
+    graph.set_title(id)
+    graph.yaxis.set_major_formatter(EngFormatter(unit=FormatterUnit))
+    graph.yaxis.set_label_text(Label)
+    graph.xaxis.set_major_formatter(EngFormatter(unit="B"))
+    graph.xaxis.set_label_text("Copy Size")
+    _ = plt.xticks(rotation=90)
+    plt.show()
+
+def displayDistributionData(id, studies, mode):
+    distributions = set()
+    df = None
+    for study in studies:
+        distribution = study["Configuration"]["SizeDistributionName"]
+        distributions.add(distribution)
+        local = pd.DataFrame(study["Measurements"], columns=["time"])
+        local["distribution"] = distribution
+        local["label"] = getLabel(study)
+        local["cycles"] = local["time"] * getCpuFrequency(study)
+        if df is None:
+            df = local
+        else:
+            df = df.append(local)
+    if mode == "bytespercycle":
+        mode = "time"
+        print("`--mode=bytespercycle` is ignored for distribution mode reports")
+    FormatterUnit = {"time":"s","cycles":""}[mode]
+    Label = {"time":"Time","cycles":"Cycles"}[mode]
+    graph = sns.violinplot(data=df, x="distribution", y=mode, palette="muted", hue="label", order=sorted(distributions))
+    graph.set_title(id)
+    graph.yaxis.set_major_formatter(EngFormatter(unit=FormatterUnit))
+    graph.yaxis.set_label_text(Label)
+    _ = plt.xticks(rotation=90)
+    plt.show()
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Process benchmark json files.")
+    parser.add_argument("--mode", choices=["time", "cycles", "bytespercycle"], default="time", help="Use to display either 'time', 'cycles' or 'bytes/cycle'.")
+    parser.add_argument("files", nargs="+", help="The json files to read from.")
+
+    args = parser.parse_args()
+    study_groups = dict()
+    for file in args.files:
+        with open(file) as json_file:
+            json_obj = json.load(json_file)
+            Id = getId(json_obj)
+            if Id in study_groups:
+                study_groups[Id].append(json_obj)
+            else:
+                study_groups[Id] = [json_obj]
+
+    plt.tight_layout()
+    sns.set_theme(style="ticks")
+    for id, study_collection in study_groups.items():
+        if "(Sweep)" in id:
+            displaySweepData(id, study_collection, args.mode)
+        else:
+            displayDistributionData(id, study_collection, args.mode)
+
+
+if __name__ == "__main__":
+    main()

libc/benchmarks/render.py3

-"""Reads JSON files produced by the benchmarking framework and renders them.
-
-Installation:
-> apt-get install python3-pip
-> pip3 install matplotlib scipy numpy
-
-Run:
-> python3 render.py3 <files>
-
-Rendering can occur on disk by specifying the --output option or on screen if
-the --headless flag is not set.
-"""
-
-import argparse
-import collections
-import json
-import math
-import pprint
-import sys
-import matplotlib.pyplot as plt
-from matplotlib.ticker import EngFormatter
-import numpy as np
-import scipy.stats
-
-
-def format_freq(number):
-    """Returns a human readable frequency."""
-    magnitude = 0
-    while math.fabs(number) >= 1000:
-        number /= 1000.0
-        magnitude += 1
-    return "%g%sHz" % (number, ["", "k", "M", "G"][magnitude])
-
-
-def format_size(number):
-    """Returns number in human readable form."""
-    magnitude = 0
-    while number >= 1000 and number % 1000 == 0:
-        number /= 1000
-        magnitude += 1
-    return "%g%s" % (number, ["", "K", "M", "G"][magnitude])
-
-
-def mean_confidence_interval(dataset, confidence=0.95):
-    """Returns the mean and half confidence interval for the dataset."""
-    a = 1.0 * np.array(dataset)
-    n = len(a)
-    m, se = np.mean(a), scipy.stats.sem(a)
-    h = se * scipy.stats.t.ppf((1 + confidence) / 2., n - 1)
-    return m, h
-
-
-def add_plot(function_name, points):
-    """Plots measurements for a function."""
-    n = len(points.keys())
-    x = np.zeros(n)
-    y = np.zeros(n)
-    yerr = np.zeros(n)
-
-    for i, key in enumerate(sorted(points.keys())):
-        values = points[key]
-        m, e = mean_confidence_interval(values)
-        x[i] = key
-        y[i] = m
-        yerr[i] = e
-
-    plt.plot(x, y, linewidth=1, label=function_name)
-    plt.fill_between(x, y - yerr, y + yerr, alpha=0.5)
-
-
-def get_title(host):
-    """Formats the Host object into a title for the plot."""
-    cpu_name = host["CpuName"]
-    cpu_freq = format_freq(host["CpuFrequency"])
-    cache_strings = []
-    for cache in host["Caches"]:
-        prefix = {
-            "Instruction": "i",
-            "Data": "d",
-            "Unified": "u",
-        }.get(cache["Type"])
-        cache_strings.append(r"%sL_%d %s_{/%d}" %
-                             (prefix, cache["Level"], format_size(
-                                 cache["Size"]), cache["NumSharing"]))
-    title = "%s (%s)" % (cpu_name, cpu_freq)
-    subtitle = r"$" + ", ".join(sorted(cache_strings)) + r"$"
-    return title + "\n" + subtitle
-
-
-def get_host(jsons):
-    """Returns the host of the different json objects iff they are all the same.
-    """
-    host = None
-    for root in jsons:
-        if host and host != root["Host"]:
-            sys.exit("The datasets are not coming from the same Host")
-        if not host:
-            host = root["Host"]
-    return host
-
-
-def get_configuration(jsons):
-    """Returns the configuration of the different json objects iff they are all
-    the same.
-    """
-    config = None
-    for root in jsons:
-        if config and config != root["Configuration"]:
-            return None
-        if not config:
-            config = root["Configuration"]
-    return config
-
-
-def setup_graphs(files, display):
-    """Setups the graphs to render from the json files."""
-    jsons = []
-    for file in files:
-        with open(file) as json_file:
-            jsons.append(json.load(json_file))
-    if not jsons:
-        sys.exit("Nothing to process")
-
-    for root in jsons:
-        frequency = root["Host"]["CpuFrequency"]
-        for function in root["Functions"]:
-            function_name = function["Name"]
-            sizes = function["Sizes"]
-            runtimes = function["Runtimes"]
-            assert len(sizes) == len(runtimes)
-            values = collections.defaultdict(lambda: [])
-            for i in range(len(sizes)):
-              value = runtimes[i]
-              if display == "cycles":
-                  value = value * frequency
-              if display == "bytespercycle":
-                  value = value * frequency
-                  value = sizes[i] / value
-              values[sizes[i]].append(value)
-            add_plot(function_name, values)
-
-    config = get_configuration(jsons)
-    if config:
-        plt.figtext(
-            0.95,
-            0.15,
-            pprint.pformat(config),
-            verticalalignment="bottom",
-            horizontalalignment="right",
-            multialignment="left",
-            fontsize="small",
-            bbox=dict(boxstyle="round", facecolor="wheat", alpha=0.5))
-
-    axes = plt.gca()
-    axes.set_title(get_title(get_host(jsons)))
-    axes.set_ylim(bottom=0)
-    axes.set_xlabel("Size")
-    axes.xaxis.set_major_formatter(EngFormatter(unit="B"))
-    if display == "cycles":
-          axes.set_ylabel("Cycles")
-    if display == "time":
-          axes.set_ylabel("Time")
-          axes.yaxis.set_major_formatter(EngFormatter(unit="s"))
-    if display == "bytespercycle":
-          axes.set_ylabel("bytes/cycle")
-
-    plt.legend()
-    plt.grid()
-
-
-def main():
-    parser = argparse.ArgumentParser(
-        description="Process benchmark json files.")
-    parser.add_argument("files", nargs="+", help="The json files to read from.")
-    parser.add_argument("--output", help="The output file to write the graph.")
-    parser.add_argument(
-        "--headless",
-        help="If set do not display the graph.",
-        action="store_true")
-    parser.add_argument(
-        "--display",
-        choices= ["time", "cycles", "bytespercycle"],
-        default="time",
-        help="Use to display either 'time', 'cycles' or 'bytes/cycle'.")
-
-    args = parser.parse_args()
-    setup_graphs(args.files, args.display)
-    if args.output:
-        plt.savefig(args.output)
-    if not args.headless:
-        plt.show()
-
-if __name__ == "__main__":
-    main()