Mercurial > hg > CbC > CbC_llvm

comparison utils/yaml-bench/YAMLBench.cpp @ 0:95c75e76d11b LLVM3.4

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
LLVM 3.4
author Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
date Thu, 12 Dec 2013 13:56:28 +0900
parents
children 54457678186b
comparison
equal deleted inserted replaced
-1:000000000000 0:95c75e76d11b
1 //===- YAMLBench - Benchmark the YAMLParser implementation ----------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This program executes the YAMLParser on differntly sized YAML texts and
11 // outputs the run time.
12 //
13 //===----------------------------------------------------------------------===//
14
15
16 #include "llvm/ADT/SmallString.h"
17 #include "llvm/Support/Casting.h"
18 #include "llvm/Support/CommandLine.h"
19 #include "llvm/Support/MemoryBuffer.h"
20 #include "llvm/Support/SourceMgr.h"
21 #include "llvm/Support/Timer.h"
22 #include "llvm/Support/YAMLParser.h"
23 #include "llvm/Support/raw_ostream.h"
24 #include "llvm/Support/system_error.h"
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 struct indent {
56 unsigned distance;
57 indent(unsigned d) : distance(d) {}
58 };
59
60 static raw_ostream &operator <<(raw_ostream &os, const indent &in) {
61 for (unsigned i = 0; i < in.distance; ++i)
62 os << " ";
63 return os;
64 }
65
66 /// \brief Pretty print a tag by replacing tag:yaml.org,2002: with !!.
67 static std::string prettyTag(yaml::Node *N) {
68 std::string Tag = N->getVerbatimTag();
69 if (StringRef(Tag).startswith("tag:yaml.org,2002:")) {
70 std::string Ret = "!!";
71 Ret += StringRef(Tag).substr(18);
72 return llvm_move(Ret);
73 }
74 std::string Ret = "!<";
75 Ret += Tag;
76 Ret += ">";
77 return Ret;
78 }
79
80 static void dumpNode( yaml::Node *n
81 , unsigned Indent = 0
82 , bool SuppressFirstIndent = false) {
83 if (!n)
84 return;
85 if (!SuppressFirstIndent)
86 outs() << indent(Indent);
87 StringRef Anchor = n->getAnchor();
88 if (!Anchor.empty())
89 outs() << "&" << Anchor << " ";
90 if (yaml::ScalarNode *sn = dyn_cast<yaml::ScalarNode>(n)) {
91 SmallString<32> Storage;
92 StringRef Val = sn->getValue(Storage);
93 outs() << prettyTag(n) << " \"" << yaml::escape(Val) << "\"";
94 } else if (yaml::SequenceNode *sn = dyn_cast<yaml::SequenceNode>(n)) {
95 outs() << prettyTag(n) << " [\n";
96 ++Indent;
97 for (yaml::SequenceNode::iterator i = sn->begin(), e = sn->end();
98 i != e; ++i) {
99 dumpNode(i, Indent);
100 outs() << ",\n";
101 }
102 --Indent;
103 outs() << indent(Indent) << "]";
104 } else if (yaml::MappingNode *mn = dyn_cast<yaml::MappingNode>(n)) {
105 outs() << prettyTag(n) << " {\n";
106 ++Indent;
107 for (yaml::MappingNode::iterator i = mn->begin(), e = mn->end();
108 i != e; ++i) {
109 outs() << indent(Indent) << "? ";
110 dumpNode(i->getKey(), Indent, true);
111 outs() << "\n";
112 outs() << indent(Indent) << ": ";
113 dumpNode(i->getValue(), Indent, true);
114 outs() << ",\n";
115 }
116 --Indent;
117 outs() << indent(Indent) << "}";
118 } else if (yaml::AliasNode *an = dyn_cast<yaml::AliasNode>(n)){
119 outs() << "*" << an->getName();
120 } else if (dyn_cast<yaml::NullNode>(n)) {
121 outs() << prettyTag(n) << " null";
122 }
123 }
124
125 static void dumpStream(yaml::Stream &stream) {
126 for (yaml::document_iterator di = stream.begin(), de = stream.end(); di != de;
127 ++di) {
128 outs() << "%YAML 1.2\n"
129 << "---\n";
130 yaml::Node *n = di->getRoot();
131 if (n)
132 dumpNode(n);
133 else
134 break;
135 outs() << "\n...\n";
136 }
137 }
138
139 static void benchmark( llvm::TimerGroup &Group
140 , llvm::StringRef Name
141 , llvm::StringRef JSONText) {
142 llvm::Timer BaseLine((Name + ": Loop").str(), Group);
143 BaseLine.startTimer();
144 char C = 0;
145 for (llvm::StringRef::iterator I = JSONText.begin(),
146 E = JSONText.end();
147 I != E; ++I) { C += *I; }
148 BaseLine.stopTimer();
149 volatile char DontOptimizeOut = C; (void)DontOptimizeOut;
150
151 llvm::Timer Tokenizing((Name + ": Tokenizing").str(), Group);
152 Tokenizing.startTimer();
153 {
154 yaml::scanTokens(JSONText);
155 }
156 Tokenizing.stopTimer();
157
158 llvm::Timer Parsing((Name + ": Parsing").str(), Group);
159 Parsing.startTimer();
160 {
161 llvm::SourceMgr SM;
162 llvm::yaml::Stream stream(JSONText, SM);
163 stream.skip();
164 }
165 Parsing.stopTimer();
166 }
167
168 static std::string createJSONText(size_t MemoryMB, unsigned ValueSize) {
169 std::string JSONText;
170 llvm::raw_string_ostream Stream(JSONText);
171 Stream << "[\n";
172 size_t MemoryBytes = MemoryMB * 1024 * 1024;
173 while (JSONText.size() < MemoryBytes) {
174 Stream << " {\n"
175 << " \"key1\": \"" << std::string(ValueSize, '*') << "\",\n"
176 << " \"key2\": \"" << std::string(ValueSize, '*') << "\",\n"
177 << " \"key3\": \"" << std::string(ValueSize, '*') << "\"\n"
178 << " }";
179 Stream.flush();
180 if (JSONText.size() < MemoryBytes) Stream << ",";
181 Stream << "\n";
182 }
183 Stream << "]\n";
184 Stream.flush();
185 return JSONText;
186 }
187
188 int main(int argc, char **argv) {
189 llvm::cl::ParseCommandLineOptions(argc, argv);
190 if (Input.getNumOccurrences()) {
191 OwningPtr<MemoryBuffer> Buf;
192 if (MemoryBuffer::getFileOrSTDIN(Input, Buf))
193 return 1;
194
195 llvm::SourceMgr sm;
196 if (DumpTokens) {
197 yaml::dumpTokens(Buf->getBuffer(), outs());
198 }
199
200 if (DumpCanonical) {
201 yaml::Stream stream(Buf->getBuffer(), sm);
202 dumpStream(stream);
203 }
204 }
205
206 if (Verify) {
207 llvm::TimerGroup Group("YAML parser benchmark");
208 benchmark(Group, "Fast", createJSONText(10, 500));
209 } else if (!DumpCanonical && !DumpTokens) {
210 llvm::TimerGroup Group("YAML parser benchmark");
211 benchmark(Group, "Small Values", createJSONText(MemoryLimitMB, 5));
212 benchmark(Group, "Medium Values", createJSONText(MemoryLimitMB, 500));
213 benchmark(Group, "Large Values", createJSONText(MemoryLimitMB, 50000));
214 }
215
216 return 0;
217 }