utils/yaml-bench/YAMLBench.cpp

   1 //===- YAMLBench - Benchmark the YAMLParser implementation ----------------===//
   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 // This program executes the YAMLParser on differently sized YAML texts and
  10 // outputs the run time.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14
  15 #include "llvm/ADT/SmallString.h"
  16 #include "llvm/Support/Casting.h"
  17 #include "llvm/Support/CommandLine.h"
  18 #include "llvm/Support/MemoryBuffer.h"
  19 #include "llvm/Support/SourceMgr.h"
  20 #include "llvm/Support/Timer.h"
  21 #include "llvm/Support/Process.h"
  22 #include "llvm/Support/YAMLParser.h"
  23 #include "llvm/Support/raw_ostream.h"
  24 #include <system_error>
  25
  26 using namespace llvm;
  27
  28 static cl::opt<bool>
  29   DumpTokens( "tokens"
  30             , cl::desc("Print the tokenization of the file.")
  31             , cl::init(false)
  32             );
  33
  34 static cl::opt<bool>
  35   DumpCanonical( "canonical"
  36                , cl::desc("Print the canonical YAML for this file.")
  37                , cl::init(false)
  38                );
  39
  40 static cl::opt<std::string>
  41  Input(cl::Positional, cl::desc("<input>"));
  42
  43 static cl::opt<bool>
  44   Verify( "verify"
  45         , cl::desc(
  46             "Run a quick verification useful for regression testing")
  47         , cl::init(false)
  48         );
  49
  50 static cl::opt<unsigned>
  51   MemoryLimitMB("memory-limit", cl::desc(
  52                   "Do not use more megabytes of memory"),
  53                 cl::init(1000));
  54
  55 cl::opt<cl::boolOrDefault>
  56     UseColor("use-color", cl::desc("Emit colored output (default=autodetect)"),
  57              cl::init(cl::BOU_UNSET));
  58
  59 struct indent {
  60   unsigned distance;
  61   indent(unsigned d) : distance(d) {}
  62 };
  63
  64 static raw_ostream &operator <<(raw_ostream &os, const indent &in) {
  65   for (unsigned i = 0; i < in.distance; ++i)
  66     os << "  ";
  67   return os;
  68 }
  69
  70 /// Pretty print a tag by replacing tag:yaml.org,2002: with !!.
  71 static std::string prettyTag(yaml::Node *N) {
  72   std::string Tag = N->getVerbatimTag();
  73   if (StringRef(Tag).startswith("tag:yaml.org,2002:")) {
  74     std::string Ret = "!!";
  75     Ret += StringRef(Tag).substr(18);
  76     return Ret;
  77   }
  78   std::string Ret = "!<";
  79   Ret += Tag;
  80   Ret += ">";
  81   return Ret;
  82 }
  83
  84 static void dumpNode( yaml::Node *n
  85                     , unsigned Indent = 0
  86                     , bool SuppressFirstIndent = false) {
  87   if (!n)
  88     return;
  89   if (!SuppressFirstIndent)
  90     outs() << indent(Indent);
  91   StringRef Anchor = n->getAnchor();
  92   if (!Anchor.empty())
  93     outs() << "&" << Anchor << " ";
  94   if (yaml::ScalarNode *sn = dyn_cast<yaml::ScalarNode>(n)) {
  95     SmallString<32> Storage;
  96     StringRef Val = sn->getValue(Storage);
  97     outs() << prettyTag(n) << " \"" << yaml::escape(Val) << "\"";
  98   } else if (yaml::BlockScalarNode *BN = dyn_cast<yaml::BlockScalarNode>(n)) {
  99     outs() << prettyTag(n) << " \"" << yaml::escape(BN->getValue()) << "\"";
 100   } else if (yaml::SequenceNode *sn = dyn_cast<yaml::SequenceNode>(n)) {
 101     outs() << prettyTag(n) << " [\n";
 102     ++Indent;
 103     for (yaml::SequenceNode::iterator i = sn->begin(), e = sn->end();
 104                                       i != e; ++i) {
 105       dumpNode(i, Indent);
 106       outs() << ",\n";
 107     }
 108     --Indent;
 109     outs() << indent(Indent) << "]";
 110   } else if (yaml::MappingNode *mn = dyn_cast<yaml::MappingNode>(n)) {
 111     outs() << prettyTag(n) << " {\n";
 112     ++Indent;
 113     for (yaml::MappingNode::iterator i = mn->begin(), e = mn->end();
 114                                      i != e; ++i) {
 115       outs() << indent(Indent) << "? ";
 116       dumpNode(i->getKey(), Indent, true);
 117       outs() << "\n";
 118       outs() << indent(Indent) << ": ";
 119       dumpNode(i->getValue(), Indent, true);
 120       outs() << ",\n";
 121     }
 122     --Indent;
 123     outs() << indent(Indent) << "}";
 124   } else if (yaml::AliasNode *an = dyn_cast<yaml::AliasNode>(n)){
 125     outs() << "*" << an->getName();
 126   } else if (isa<yaml::NullNode>(n)) {
 127     outs() << prettyTag(n) << " null";
 128   }
 129 }
 130
 131 static void dumpStream(yaml::Stream &stream) {
 132   for (yaml::document_iterator di = stream.begin(), de = stream.end(); di != de;
 133        ++di) {
 134     outs() << "%YAML 1.2\n"
 135            << "---\n";
 136     yaml::Node *n = di->getRoot();
 137     if (n)
 138       dumpNode(n);
 139     else
 140       break;
 141     outs() << "\n...\n";
 142   }
 143 }
 144
 145 static void benchmark(llvm::TimerGroup &Group, llvm::StringRef Name,
 146                       llvm::StringRef Description, llvm::StringRef JSONText) {
 147   llvm::Timer BaseLine((Name + ".loop").str(), (Description + ": Loop").str(),
 148                        Group);
 149   BaseLine.startTimer();
 150   char C = 0;
 151   for (llvm::StringRef::iterator I = JSONText.begin(),
 152                                  E = JSONText.end();
 153        I != E; ++I) { C += *I; }
 154   BaseLine.stopTimer();
 155   volatile char DontOptimizeOut = C; (void)DontOptimizeOut;
 156
 157   llvm::Timer Tokenizing((Name + ".tokenizing").str(),
 158                          (Description + ": Tokenizing").str(), Group);
 159   Tokenizing.startTimer();
 160   {
 161     yaml::scanTokens(JSONText);
 162   }
 163   Tokenizing.stopTimer();
 164
 165   llvm::Timer Parsing((Name + ".parsing").str(),
 166                       (Description + ": Parsing").str(), Group);
 167   Parsing.startTimer();
 168   {
 169     llvm::SourceMgr SM;
 170     llvm::yaml::Stream stream(JSONText, SM);
 171     stream.skip();
 172   }
 173   Parsing.stopTimer();
 174 }
 175
 176 static std::string createJSONText(size_t MemoryMB, unsigned ValueSize) {
 177   std::string JSONText;
 178   llvm::raw_string_ostream Stream(JSONText);
 179   Stream << "[\n";
 180   size_t MemoryBytes = MemoryMB * 1024 * 1024;
 181   while (JSONText.size() < MemoryBytes) {
 182     Stream << " {\n"
 183            << "  \"key1\": \"" << std::string(ValueSize, '*') << "\",\n"
 184            << "  \"key2\": \"" << std::string(ValueSize, '*') << "\",\n"
 185            << "  \"key3\": \"" << std::string(ValueSize, '*') << "\"\n"
 186            << " }";
 187     Stream.flush();
 188     if (JSONText.size() < MemoryBytes) Stream << ",";
 189     Stream << "\n";
 190   }
 191   Stream << "]\n";
 192   Stream.flush();
 193   return JSONText;
 194 }
 195
 196 int main(int argc, char **argv) {
 197   llvm::cl::ParseCommandLineOptions(argc, argv);
 198   bool ShowColors = UseColor == cl::BOU_UNSET
 199                         ? sys::Process::StandardOutHasColors()
 200                         : UseColor == cl::BOU_TRUE;
 201   if (Input.getNumOccurrences()) {
 202     ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
 203         MemoryBuffer::getFileOrSTDIN(Input);
 204     if (!BufOrErr)
 205       return 1;
 206     MemoryBuffer &Buf = *BufOrErr.get();
 207
 208     llvm::SourceMgr sm;
 209     if (DumpTokens) {
 210       yaml::dumpTokens(Buf.getBuffer(), outs());
 211     }
 212
 213     if (DumpCanonical) {
 214       yaml::Stream stream(Buf.getBuffer(), sm, ShowColors);
 215       dumpStream(stream);
 216       if (stream.failed())
 217         return 1;
 218     }
 219   }
 220
 221   if (Verify) {
 222     llvm::TimerGroup Group("yaml", "YAML parser benchmark");
 223     benchmark(Group, "Fast", "Fast", createJSONText(10, 500));
 224   } else if (!DumpCanonical && !DumpTokens) {
 225     llvm::TimerGroup Group("yaml", "YAML parser benchmark");
 226     benchmark(Group, "Small", "Small Values", createJSONText(MemoryLimitMB, 5));
 227     benchmark(Group, "Medium", "Medium Values",
 228               createJSONText(MemoryLimitMB, 500));
 229     benchmark(Group, "Large", "Large Values",
 230               createJSONText(MemoryLimitMB, 50000));
 231   }
 232
 233   return 0;
 234 }