libc/benchmarks/LibcMemoryBenchmark.cpp

   1 //===-- Benchmark memory specific tools -----------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "LibcMemoryBenchmark.h"
  10 #include "llvm/ADT/SmallVector.h"
  11 #include "llvm/ADT/Twine.h"
  12 #include "llvm/Support/ErrorHandling.h"
  13 #include "llvm/Support/MathExtras.h"
  14 #include <algorithm>
  15
  16 namespace llvm {
  17 namespace libc_benchmarks {
  18
  19 // Returns a distribution that samples the buffer to satisfy the required
  20 // alignment.
  21 // When alignment is set, the distribution is scaled down by `Factor` and scaled
  22 // up again by the same amount during sampling.
  23 static std::uniform_int_distribution<uint32_t>
  24 getOffsetDistribution(size_t BufferSize, size_t MaxSizeValue,
  25                       MaybeAlign AccessAlignment) {
  26   if (AccessAlignment && *AccessAlignment > AlignedBuffer::Alignment)
  27     report_fatal_error(
  28         "AccessAlignment must be less or equal to AlignedBuffer::Alignment");
  29   if (!AccessAlignment)
  30     return std::uniform_int_distribution<uint32_t>(0, 0); // Always 0.
  31   // If we test up to Size bytes, the returned offset must stay under
  32   // BuffersSize - Size.
  33   int64_t MaxOffset = BufferSize;
  34   MaxOffset -= MaxSizeValue;
  35   MaxOffset -= 1;
  36   if (MaxOffset < 0)
  37     report_fatal_error(
  38         "BufferSize too small to exercise specified Size configuration");
  39   MaxOffset /= AccessAlignment->value();
  40   return std::uniform_int_distribution<uint32_t>(0, MaxOffset);
  41 }
  42
  43 OffsetDistribution::OffsetDistribution(size_t BufferSize, size_t MaxSizeValue,
  44                                        MaybeAlign AccessAlignment)
  45     : Distribution(
  46           getOffsetDistribution(BufferSize, MaxSizeValue, AccessAlignment)),
  47       Factor(AccessAlignment.valueOrOne().value()) {}
  48
  49 // Precomputes offset where to insert mismatches between the two buffers.
  50 MismatchOffsetDistribution::MismatchOffsetDistribution(size_t BufferSize,
  51                                                        size_t MaxSizeValue,
  52                                                        size_t MismatchAt)
  53     : MismatchAt(MismatchAt) {
  54   if (MismatchAt <= 1)
  55     return;
  56   for (size_t I = MaxSizeValue + 1; I < BufferSize; I += MaxSizeValue)
  57     MismatchIndices.push_back(I);
  58   if (MismatchIndices.empty())
  59     report_fatal_error("Unable to generate mismatch");
  60   MismatchIndexSelector =
  61       std::uniform_int_distribution<size_t>(0, MismatchIndices.size() - 1);
  62 }
  63
  64 static size_t getL1DataCacheSize() {
  65   const std::vector<CacheInfo> &CacheInfos = HostState::get().Caches;
  66   const auto IsL1DataCache = [](const CacheInfo &CI) {
  67     return CI.Type == "Data" && CI.Level == 1;
  68   };
  69   const auto CacheIt = find_if(CacheInfos, IsL1DataCache);
  70   if (CacheIt != CacheInfos.end())
  71     return CacheIt->Size;
  72   report_fatal_error("Unable to read L1 Cache Data Size");
  73 }
  74
  75 static constexpr int64_t KiB = 1024;
  76 static constexpr int64_t ParameterStorageBytes = 4 * KiB;
  77 static constexpr int64_t L1LeftAsideBytes = 1 * KiB;
  78
  79 static size_t getAvailableBufferSize() {
  80   return getL1DataCacheSize() - L1LeftAsideBytes - ParameterStorageBytes;
  81 }
  82
  83 ParameterBatch::ParameterBatch(size_t BufferCount)
  84     : BufferSize(getAvailableBufferSize() / BufferCount),
  85       BatchSize(ParameterStorageBytes / sizeof(ParameterType)),
  86       Parameters(BatchSize) {
  87   if (BufferSize <= 0 || BatchSize < 100)
  88     report_fatal_error("Not enough L1 cache");
  89   const size_t ParameterBytes = Parameters.size() * sizeof(ParameterType);
  90   const size_t BufferBytes = BufferSize * BufferCount;
  91   if (ParameterBytes + BufferBytes + L1LeftAsideBytes > getL1DataCacheSize())
  92     report_fatal_error(
  93         "We're splitting a buffer of the size of the L1 cache between a data "
  94         "buffer and a benchmark parameters buffer, so by construction the "
  95         "total should not exceed the size of the L1 cache");
  96 }
  97
  98 size_t ParameterBatch::getBatchBytes() const {
  99   size_t BatchBytes = 0;
 100   for (auto &P : Parameters)
 101     BatchBytes += P.SizeBytes;
 102   return BatchBytes;
 103 }
 104
 105 void ParameterBatch::checkValid(const ParameterType &P) const {
 106   if (P.OffsetBytes + P.SizeBytes >= BufferSize)
 107     report_fatal_error(
 108         llvm::Twine("Call would result in buffer overflow: Offset=")
 109             .concat(llvm::Twine(P.OffsetBytes))
 110             .concat(", Size=")
 111             .concat(llvm::Twine(P.SizeBytes))
 112             .concat(", BufferSize=")
 113             .concat(llvm::Twine(BufferSize)));
 114 }
 115
 116 CopySetup::CopySetup()
 117     : ParameterBatch(2), SrcBuffer(ParameterBatch::BufferSize),
 118       DstBuffer(ParameterBatch::BufferSize) {}
 119
 120 MoveSetup::MoveSetup()
 121     : ParameterBatch(3), Buffer(ParameterBatch::BufferSize * 3) {}
 122
 123 ComparisonSetup::ComparisonSetup()
 124     : ParameterBatch(2), LhsBuffer(ParameterBatch::BufferSize),
 125       RhsBuffer(ParameterBatch::BufferSize) {
 126   // The memcmp buffers always compare equal.
 127   memset(LhsBuffer.begin(), 0xF, BufferSize);
 128   memset(RhsBuffer.begin(), 0xF, BufferSize);
 129 }
 130
 131 SetSetup::SetSetup()
 132     : ParameterBatch(1), DstBuffer(ParameterBatch::BufferSize) {}
 133
 134 } // namespace libc_benchmarks
 135 } // namespace llvm