1072

pending completion

Build # 1072

Build Type

push

travis-ci

Committed by

dominichamon

Commit Message

<a href="https://github.com/google/benchmark/commit/<a class=hub.com/google/benchmark/commit/<a class="double-link" href="https://git"><a class=hub.com/google/benchmark/commit/<a class="double-link" href="https://git"><a class=hub.com/google/benchmark/commit/c7192c8a9af0a1cb4d013c589af92d6dceedef60">c7192c8a9">&lt;a href=&quot;https://github.com/google/benchmark/commit/</a><a class="double-link" href="https://github.com/google/benchmark/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/google/benchmark/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/google/benchmark/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/google/benchmark/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/google/benchmark/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/google/benchmark/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/google/benchmark/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/google/benchmark/commit/c7192c8a9af0a1cb4d013c589af92d6dceedef60">c7192c8a9</a><a href="https://github.com/google/benchmark/commit/c7192c8a9af0a1cb4d013c589af92d6dceedef60">&lt;a href=&quot;https://github.com/google/benchmark/commit/c7192c8a9af0a1cb4d013c589af92d6dceedef60&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/google/benchmark/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/google/benchmark/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;amp;quot;https://git&amp;quot;&amp;gt;&amp;amp;lt;a class=&amp;lt;/a&amp;gt;hub.com/google/benchmark/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;amp;quot;https://git&amp;quot;&amp;gt;&amp;amp;lt;a class=&amp;lt;/a&amp;gt;hub.com/google/benchmark/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;amp;quot;https://git&amp;quot;&amp;gt;&amp;amp;lt;a class=&amp;lt;/a&amp;gt;hub.com/google/bench... (continued)

Run Details

1401 of 1614 relevant lines covered (86.8%)

3638839.8 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

89.38

/src/complexity.cc

// Copyright 2016 Ismael Jimenez Martinez. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Source project : https://github.com/ismaelJimenez/cpp.leastsq
// Adapted to be used with google benchmark

#include "benchmark/benchmark.h"

#include <algorithm>
#include <cmath>
#include "check.h"
#include "complexity.h"
#include "stat.h"

namespace benchmark {

// Internal function to calculate the different scalability forms
BigOFunc* FittingCurve(BigO complexity) {
  switch (complexity) {
    case oN:
      return [](int n) -> double { return n; };
    case oNSquared:
      return [](int n) -> double { return std::pow(n, 2); };
    case oNCubed:
      return [](int n) -> double { return std::pow(n, 3); };
    case oLogN:
      return [](int n) { return log2(n); };
    case oNLogN:
      return [](int n) { return n * log2(n); };
    case o1:
    default:
      return [](int) { return 1.0; };
  }
}

// Function to return an string for the calculated complexity
std::string GetBigOString(BigO complexity) {
  switch (complexity) {
    case oN:
      return "N";
    case oNSquared:
      return "N^2";
    case oNCubed:
      return "N^3";
    case oLogN:
      return "lgN";
    case oNLogN:
      return "NlgN";
    case o1:
      return "(1)";
    default:
      return "f(N)";
  }
}

// Find the coefficient for the high-order term in the running time, by
// minimizing the sum of squares of relative error, for the fitting curve
// given by the lambda expresion.
//   - n             : Vector containing the size of the benchmark tests.
//   - time          : Vector containing the times for the benchmark tests.
//   - fitting_curve : lambda expresion (e.g. [](int n) {return n; };).

// For a deeper explanation on the algorithm logic, look the README file at
// http://github.com/ismaelJimenez/Minimal-Cpp-Least-Squared-Fit

LeastSq MinimalLeastSq(const std::vector<int>& n,
                       const std::vector<double>& time,
                       BigOFunc* fitting_curve) {
  double sigma_gn = 0.0;
  double sigma_gn_squared = 0.0;
  double sigma_time = 0.0;
  double sigma_time_gn = 0.0;

  // Calculate least square fitting parameter
  for (size_t i = 0; i < n.size(); ++i) {
    double gn_i = fitting_curve(n[i]);
    sigma_gn += gn_i;
    sigma_gn_squared += gn_i * gn_i;
    sigma_time += time[i];
    sigma_time_gn += time[i] * gn_i;
  }

  LeastSq result;
  result.complexity = oLambda;

  // Calculate complexity.
  result.coef = sigma_time_gn / sigma_gn_squared;

  // Calculate RMS
  double rms = 0.0;
  for (size_t i = 0; i < n.size(); ++i) {
    double fit = result.coef * fitting_curve(n[i]);
    rms += pow((time[i] - fit), 2);
  }

  // Normalized RMS by the mean of the observed values
  double mean = sigma_time / n.size();
  result.rms = sqrt(rms / n.size()) / mean;

  return result;
}

// Find the coefficient for the high-order term in the running time, by
// minimizing the sum of squares of relative error.
//   - n          : Vector containing the size of the benchmark tests.
//   - time       : Vector containing the times for the benchmark tests.
//   - complexity : If different than oAuto, the fitting curve will stick to
//                  this one. If it is oAuto, it will be calculated the best
//                  fitting curve.
LeastSq MinimalLeastSq(const std::vector<int>& n,
                       const std::vector<double>& time, const BigO complexity) {
  CHECK_EQ(n.size(), time.size());
  CHECK_GE(n.size(), 2);  // Do not compute fitting curve is less than two
                          // benchmark runs are given
  CHECK_NE(complexity, oNone);

  LeastSq best_fit;

  if (complexity == oAuto) {
    std::vector<BigO> fit_curves = {oLogN, oN, oNLogN, oNSquared, oNCubed};

    // Take o1 as default best fitting curve
    best_fit = MinimalLeastSq(n, time, FittingCurve(o1));
    best_fit.complexity = o1;

    // Compute all possible fitting curves and stick to the best one
    for (const auto& fit : fit_curves) {
      LeastSq current_fit = MinimalLeastSq(n, time, FittingCurve(fit));
      if (current_fit.rms < best_fit.rms) {
        best_fit = current_fit;
        best_fit.complexity = fit;
      }
    }
  } else {
    best_fit = MinimalLeastSq(n, time, FittingCurve(complexity));
    best_fit.complexity = complexity;
  }

  return best_fit;
}

std::vector<BenchmarkReporter::Run> ComputeStats(
    const std::vector<BenchmarkReporter::Run>& reports) {
  typedef BenchmarkReporter::Run Run;
  std::vector<Run> results;

  auto error_count =
      std::count_if(reports.begin(), reports.end(),
                    [](Run const& run) { return run.error_occurred; });

  if (reports.size() - error_count < 2) {
    // We don't report aggregated data if there was a single run.
    return results;
  }
  // Accumulators.
  Stat1_d real_accumulated_time_stat;
  Stat1_d cpu_accumulated_time_stat;
  Stat1_d bytes_per_second_stat;
  Stat1_d items_per_second_stat;
  // All repetitions should be run with the same number of iterations so we
  // can take this information from the first benchmark.
  int64_t const run_iterations = reports.front().iterations;
  // create stats for user counters
  struct CounterStat {
    Counter c;
    Stat1_d s;
  };
  std::map< std::string, CounterStat > counter_stats;
  for(Run const& r : reports) {
    for(auto const& cnt : r.counters) {
      auto it = counter_stats.find(cnt.first);
      if(it == counter_stats.end()) {
        counter_stats.insert({cnt.first, {cnt.second, Stat1_d{}}});
      } else {
        CHECK_EQ(counter_stats[cnt.first].c.flags, cnt.second.flags);
      }
    }
  }

  // Populate the accumulators.
  for (Run const& run : reports) {
    CHECK_EQ(reports[0].benchmark_name, run.benchmark_name);
    CHECK_EQ(run_iterations, run.iterations);
    if (run.error_occurred) continue;
    real_accumulated_time_stat +=
        Stat1_d(run.real_accumulated_time / run.iterations);
    cpu_accumulated_time_stat +=
        Stat1_d(run.cpu_accumulated_time / run.iterations);
    items_per_second_stat += Stat1_d(run.items_per_second);
    bytes_per_second_stat += Stat1_d(run.bytes_per_second);
    // user counters
    for(auto const& cnt : run.counters) {
      auto it = counter_stats.find(cnt.first);
      CHECK_NE(it, counter_stats.end());
      it->second.s += Stat1_d(cnt.second);
    }
  }

  // Get the data from the accumulator to BenchmarkReporter::Run's.
  Run mean_data;
  mean_data.benchmark_name = reports[0].benchmark_name + "_mean";
  mean_data.iterations = run_iterations;
  mean_data.real_accumulated_time =
      real_accumulated_time_stat.Mean() * run_iterations;
  mean_data.cpu_accumulated_time =
      cpu_accumulated_time_stat.Mean() * run_iterations;
  mean_data.bytes_per_second = bytes_per_second_stat.Mean();
  mean_data.items_per_second = items_per_second_stat.Mean();
  mean_data.time_unit = reports[0].time_unit;
  // user counters
  for(auto const& kv : counter_stats) {
    auto c = Counter(kv.second.s.Mean(), counter_stats[kv.first].c.flags);
    mean_data.counters[kv.first] = c;
  }

  // Only add label to mean/stddev if it is same for all runs
  mean_data.report_label = reports[0].report_label;
  for (std::size_t i = 1; i < reports.size(); i++) {
    if (reports[i].report_label != reports[0].report_label) {
      mean_data.report_label = "";
      break;
    }
  }

  Run stddev_data;
  stddev_data.benchmark_name = reports[0].benchmark_name + "_stddev";
  stddev_data.report_label = mean_data.report_label;
  stddev_data.iterations = 0;
  stddev_data.real_accumulated_time = real_accumulated_time_stat.StdDev();
  stddev_data.cpu_accumulated_time = cpu_accumulated_time_stat.StdDev();
  stddev_data.bytes_per_second = bytes_per_second_stat.StdDev();
  stddev_data.items_per_second = items_per_second_stat.StdDev();
  stddev_data.time_unit = reports[0].time_unit;
  // user counters
  for(auto const& kv : counter_stats) {
    auto c = Counter(kv.second.s.StdDev(), counter_stats[kv.first].c.flags);
    stddev_data.counters[kv.first] = c;
  }

  results.push_back(mean_data);
  results.push_back(stddev_data);
  return results;
}

std::vector<BenchmarkReporter::Run> ComputeBigO(
    const std::vector<BenchmarkReporter::Run>& reports) {
  typedef BenchmarkReporter::Run Run;
  std::vector<Run> results;

  if (reports.size() < 2) return results;

  // Accumulators.
  std::vector<int> n;
  std::vector<double> real_time;
  std::vector<double> cpu_time;

  // Populate the accumulators.
  for (const Run& run : reports) {
    CHECK_GT(run.complexity_n, 0) << "Did you forget to call SetComplexityN?";
    n.push_back(run.complexity_n);
    real_time.push_back(run.real_accumulated_time / run.iterations);
    cpu_time.push_back(run.cpu_accumulated_time / run.iterations);
  }

  LeastSq result_cpu;
  LeastSq result_real;

  if (reports[0].complexity == oLambda) {
    result_cpu = MinimalLeastSq(n, cpu_time, reports[0].complexity_lambda);
    result_real = MinimalLeastSq(n, real_time, reports[0].complexity_lambda);
  } else {
    result_cpu = MinimalLeastSq(n, cpu_time, reports[0].complexity);
    result_real = MinimalLeastSq(n, real_time, result_cpu.complexity);
  }
  std::string benchmark_name =
      reports[0].benchmark_name.substr(0, reports[0].benchmark_name.find('/'));

  // Get the data from the accumulator to BenchmarkReporter::Run's.
  Run big_o;
  big_o.benchmark_name = benchmark_name + "_BigO";
  big_o.iterations = 0;
  big_o.real_accumulated_time = result_real.coef;
  big_o.cpu_accumulated_time = result_cpu.coef;
  big_o.report_big_o = true;
  big_o.complexity = result_cpu.complexity;

  // All the time results are reported after being multiplied by the
  // time unit multiplier. But since RMS is a relative quantity it
  // should not be multiplied at all. So, here, we _divide_ it by the
  // multiplier so that when it is multiplied later the result is the
  // correct one.
  double multiplier = GetTimeUnitMultiplier(reports[0].time_unit);

  // Only add label to mean/stddev if it is same for all runs
  Run rms;
  big_o.report_label = reports[0].report_label;
  rms.benchmark_name = benchmark_name + "_RMS";
  rms.report_label = big_o.report_label;
  rms.iterations = 0;
  rms.real_accumulated_time = result_real.rms / multiplier;
  rms.cpu_accumulated_time = result_cpu.rms / multiplier;
  rms.report_rms = true;
  rms.complexity = result_cpu.complexity;
  // don't forget to keep the time unit, or we won't be able to
  // recover the correct value.
  rms.time_unit = reports[0].time_unit;

  results.push_back(big_o);
  results.push_back(rms);
  return results;
}

}  // end namespace benchmark

1	// Copyright 2016 Ismael Jimenez Martinez. All rights reserved.
2	//
3	// Licensed under the Apache License, Version 2.0 (the "License");
4	// you may not use this file except in compliance with the License.
5	// You may obtain a copy of the License at
6	//
7	// http://www.apache.org/licenses/LICENSE-2.0
8	//
9	// Unless required by applicable law or agreed to in writing, software
10	// distributed under the License is distributed on an "AS IS" BASIS,
11	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12	// See the License for the specific language governing permissions and
13	// limitations under the License.
14
15	// Source project : https://github.com/ismaelJimenez/cpp.leastsq
16	// Adapted to be used with google benchmark
17
18	#include "benchmark/benchmark.h"
19
20	#include <algorithm>
21	#include <cmath>
22	#include "check.h"
23	#include "complexity.h"
24	#include "stat.h"
25
26	namespace benchmark {
27
28	// Internal function to calculate the different scalability forms
29	BigOFunc* FittingCurve(BigO complexity) {	29✔
30	switch (complexity) {	29✔
31	case oN:
32	return [](int n) -> double { return n; };	180✔
33	case oNSquared:
34	return [](int n) -> double { return std::pow(n, 2); };	90✔
35	case oNCubed:
36	return [](int n) -> double { return std::pow(n, 3); };	90✔
37	case oLogN:
38	return [](int n) { return log2(n); };	90✔
39	case oNLogN:
40	return [](int n) { return n * log2(n); };	180✔
41	case o1:
42	default:
43	return [](int) { return 1.0; };	240✔
44	}
45	}
46
47	// Function to return an string for the calculated complexity
48	std::string GetBigOString(BigO complexity) {	30✔
49	switch (complexity) {	30✔
50	case oN:
51	return "N";	6✔
52	case oNSquared:
53	return "N^2";	×
54	case oNCubed:
55	return "N^3";	×
56	case oLogN:
57	return "lgN";	×
58	case oNLogN:
59	return "NlgN";	6✔
60	case o1:
61	return "(1)";	9✔
62	default:
63	return "f(N)";	9✔
64	}
65	}
66
67	// Find the coefficient for the high-order term in the running time, by
68	// minimizing the sum of squares of relative error, for the fitting curve
69	// given by the lambda expresion.
70	// - n : Vector containing the size of the benchmark tests.
71	// - time : Vector containing the times for the benchmark tests.
72	// - fitting_curve : lambda expresion (e.g. [](int n) {return n; };).
73
74	// For a deeper explanation on the algorithm logic, look the README file at
75	// http://github.com/ismaelJimenez/Minimal-Cpp-Least-Squared-Fit
76
77	LeastSq MinimalLeastSq(const std::vector<int>& n,	35✔
78	const std::vector<double>& time,
79	BigOFunc* fitting_curve) {
80	double sigma_gn = 0.0;	35✔
81	double sigma_gn_squared = 0.0;	35✔
82	double sigma_time = 0.0;	35✔
83	double sigma_time_gn = 0.0;	35✔
84
85	// Calculate least square fitting parameter
86	for (size_t i = 0; i < n.size(); ++i) {	280✔
87	double gn_i = fitting_curve(n[i]);	245✔
88	sigma_gn += gn_i;	245✔
89	sigma_gn_squared += gn_i * gn_i;	245✔
90	sigma_time += time[i];	245✔
91	sigma_time_gn += time[i] * gn_i;	245✔
92	}
93
94	LeastSq result;	35✔
95	result.complexity = oLambda;	35✔
96
97	// Calculate complexity.
98	result.coef = sigma_time_gn / sigma_gn_squared;	35✔
99
100	// Calculate RMS
101	double rms = 0.0;	35✔
102	for (size_t i = 0; i < n.size(); ++i) {	280✔
103	double fit = result.coef * fitting_curve(n[i]);	245✔
104	rms += pow((time[i] - fit), 2);	245✔
105	}
106
107	// Normalized RMS by the mean of the observed values
108	double mean = sigma_time / n.size();	35✔
109	result.rms = sqrt(rms / n.size()) / mean;	35✔
110
111	return result;	35✔
112	}
113
114	// Find the coefficient for the high-order term in the running time, by
115	// minimizing the sum of squares of relative error.
116	// - n : Vector containing the size of the benchmark tests.
117	// - time : Vector containing the times for the benchmark tests.
118	// - complexity : If different than oAuto, the fitting curve will stick to
119	// this one. If it is oAuto, it will be calculated the best
120	// fitting curve.
121	LeastSq MinimalLeastSq(const std::vector<int>& n,	14✔
122	const std::vector<double>& time, const BigO complexity) {
123	CHECK_EQ(n.size(), time.size());	14✔
124	CHECK_GE(n.size(), 2); // Do not compute fitting curve is less than two	14✔
125	// benchmark runs are given
126	CHECK_NE(complexity, oNone);	14✔
127
128	LeastSq best_fit;	14✔
129
130	if (complexity == oAuto) {	14✔
131	std::vector<BigO> fit_curves = {oLogN, oN, oNLogN, oNSquared, oNCubed};	3✔
132
133	// Take o1 as default best fitting curve
134	best_fit = MinimalLeastSq(n, time, FittingCurve(o1));	3✔
135	best_fit.complexity = o1;	3✔
136
137	// Compute all possible fitting curves and stick to the best one
138	for (const auto& fit : fit_curves) {	18✔
139	LeastSq current_fit = MinimalLeastSq(n, time, FittingCurve(fit));	15✔
140	if (current_fit.rms < best_fit.rms) {	15✔
141	best_fit = current_fit;	5✔
142	best_fit.complexity = fit;	5✔
143	}
144	}	3✔
145	} else {
146	best_fit = MinimalLeastSq(n, time, FittingCurve(complexity));	11✔
147	best_fit.complexity = complexity;	11✔
148	}
149
150	return best_fit;	14✔
151	}
152
153	std::vector<BenchmarkReporter::Run> ComputeStats(	376✔
154	const std::vector<BenchmarkReporter::Run>& reports) {
155	typedef BenchmarkReporter::Run Run;
156	std::vector<Run> results;	376✔
157
158	auto error_count =
159	std::count_if(reports.begin(), reports.end(),
160	[](Run const& run) { return run.error_occurred; });	760✔
161
162	if (reports.size() - error_count < 2) {	376✔
163	// We don't report aggregated data if there was a single run.
164	return results;	372✔
165	}
166	// Accumulators.
167	Stat1_d real_accumulated_time_stat;	4✔
168	Stat1_d cpu_accumulated_time_stat;	4✔
169	Stat1_d bytes_per_second_stat;	4✔
170	Stat1_d items_per_second_stat;	4✔
171	// All repetitions should be run with the same number of iterations so we
172	// can take this information from the first benchmark.
173	int64_t const run_iterations = reports.front().iterations;	4✔
174	// create stats for user counters
175	struct CounterStat {	×
176	Counter c;
177	Stat1_d s;
178	};
179	std::map< std::string, CounterStat > counter_stats;	8✔
180	for(Run const& r : reports) {	16✔
181	for(auto const& cnt : r.counters) {	12✔
182	auto it = counter_stats.find(cnt.first);	×
183	if(it == counter_stats.end()) {	×
184	counter_stats.insert({cnt.first, {cnt.second, Stat1_d{}}});	×
185	} else {
186	CHECK_EQ(counter_stats[cnt.first].c.flags, cnt.second.flags);	×
187	}
188	}
189	}
190
191	// Populate the accumulators.
192	for (Run const& run : reports) {	16✔
193	CHECK_EQ(reports[0].benchmark_name, run.benchmark_name);	12✔
194	CHECK_EQ(run_iterations, run.iterations);	12✔
195	if (run.error_occurred) continue;	12✔
196	real_accumulated_time_stat +=	24✔
197	Stat1_d(run.real_accumulated_time / run.iterations);	24✔
198	cpu_accumulated_time_stat +=	24✔
199	Stat1_d(run.cpu_accumulated_time / run.iterations);	24✔
200	items_per_second_stat += Stat1_d(run.items_per_second);	12✔
201	bytes_per_second_stat += Stat1_d(run.bytes_per_second);	12✔
202	// user counters
203	for(auto const& cnt : run.counters) {	12✔
204	auto it = counter_stats.find(cnt.first);	×
205	CHECK_NE(it, counter_stats.end());	×
206	it->second.s += Stat1_d(cnt.second);	×
207	}
208	}
209
210	// Get the data from the accumulator to BenchmarkReporter::Run's.
211	Run mean_data;	8✔
212	mean_data.benchmark_name = reports[0].benchmark_name + "_mean";	4✔
213	mean_data.iterations = run_iterations;	4✔
214	mean_data.real_accumulated_time =
215	real_accumulated_time_stat.Mean() * run_iterations;	4✔
216	mean_data.cpu_accumulated_time =
217	cpu_accumulated_time_stat.Mean() * run_iterations;	4✔
218	mean_data.bytes_per_second = bytes_per_second_stat.Mean();	4✔
219	mean_data.items_per_second = items_per_second_stat.Mean();	4✔
220	mean_data.time_unit = reports[0].time_unit;	4✔
221	// user counters
222	for(auto const& kv : counter_stats) {	4✔
223	auto c = Counter(kv.second.s.Mean(), counter_stats[kv.first].c.flags);	×
224	mean_data.counters[kv.first] = c;	×
225	}
226
227	// Only add label to mean/stddev if it is same for all runs
228	mean_data.report_label = reports[0].report_label;	4✔
229	for (std::size_t i = 1; i < reports.size(); i++) {	12✔
230	if (reports[i].report_label != reports[0].report_label) {	8✔
231	mean_data.report_label = "";	×
232	break;	×
233	}
234	}
235
236	Run stddev_data;	8✔
237	stddev_data.benchmark_name = reports[0].benchmark_name + "_stddev";	4✔
238	stddev_data.report_label = mean_data.report_label;	4✔
239	stddev_data.iterations = 0;	4✔
240	stddev_data.real_accumulated_time = real_accumulated_time_stat.StdDev();	4✔
241	stddev_data.cpu_accumulated_time = cpu_accumulated_time_stat.StdDev();	4✔
242	stddev_data.bytes_per_second = bytes_per_second_stat.StdDev();	4✔
243	stddev_data.items_per_second = items_per_second_stat.StdDev();	4✔
244	stddev_data.time_unit = reports[0].time_unit;	4✔
245	// user counters
246	for(auto const& kv : counter_stats) {	4✔
247	auto c = Counter(kv.second.s.StdDev(), counter_stats[kv.first].c.flags);	×
248	stddev_data.counters[kv.first] = c;	×
249	}
250
251	results.push_back(mean_data);	4✔
252	results.push_back(stddev_data);	4✔
253	return results;	4✔
254	}
255
256	std::vector<BenchmarkReporter::Run> ComputeBigO(	10✔
257	const std::vector<BenchmarkReporter::Run>& reports) {
258	typedef BenchmarkReporter::Run Run;
259	std::vector<Run> results;	10✔
260
261	if (reports.size() < 2) return results;	10✔
262
263	// Accumulators.
264	std::vector<int> n;	20✔
265	std::vector<double> real_time;	20✔
266	std::vector<double> cpu_time;	20✔
267
268	// Populate the accumulators.
269	for (const Run& run : reports) {	80✔
270	CHECK_GT(run.complexity_n, 0) << "Did you forget to call SetComplexityN?";	70✔
271	n.push_back(run.complexity_n);	70✔
272	real_time.push_back(run.real_accumulated_time / run.iterations);	70✔
273	cpu_time.push_back(run.cpu_accumulated_time / run.iterations);	70✔
274	}
275
276	LeastSq result_cpu;	10✔
277	LeastSq result_real;	10✔
278
279	if (reports[0].complexity == oLambda) {	10✔
280	result_cpu = MinimalLeastSq(n, cpu_time, reports[0].complexity_lambda);	3✔
281	result_real = MinimalLeastSq(n, real_time, reports[0].complexity_lambda);	3✔
282	} else {
283	result_cpu = MinimalLeastSq(n, cpu_time, reports[0].complexity);	7✔
284	result_real = MinimalLeastSq(n, real_time, result_cpu.complexity);	7✔
285	}
286	std::string benchmark_name =
287	reports[0].benchmark_name.substr(0, reports[0].benchmark_name.find('/'));	20✔
288
289	// Get the data from the accumulator to BenchmarkReporter::Run's.
290	Run big_o;	20✔
291	big_o.benchmark_name = benchmark_name + "_BigO";	10✔
292	big_o.iterations = 0;	10✔
293	big_o.real_accumulated_time = result_real.coef;	10✔
294	big_o.cpu_accumulated_time = result_cpu.coef;	10✔
295	big_o.report_big_o = true;	10✔
296	big_o.complexity = result_cpu.complexity;	10✔
297
298	// All the time results are reported after being multiplied by the
299	// time unit multiplier. But since RMS is a relative quantity it
300	// should not be multiplied at all. So, here, we _divide_ it by the
301	// multiplier so that when it is multiplied later the result is the
302	// correct one.
303	double multiplier = GetTimeUnitMultiplier(reports[0].time_unit);	10✔
304
305	// Only add label to mean/stddev if it is same for all runs
306	Run rms;	20✔
307	big_o.report_label = reports[0].report_label;	10✔
308	rms.benchmark_name = benchmark_name + "_RMS";	10✔
309	rms.report_label = big_o.report_label;	10✔
310	rms.iterations = 0;	10✔
311	rms.real_accumulated_time = result_real.rms / multiplier;	10✔
312	rms.cpu_accumulated_time = result_cpu.rms / multiplier;	10✔
313	rms.report_rms = true;	10✔
314	rms.complexity = result_cpu.complexity;	10✔
315	// don't forget to keep the time unit, or we won't be able to
316	// recover the correct value.
317	rms.time_unit = reports[0].time_unit;	10✔
318
319	results.push_back(big_o);	10✔
320	results.push_back(rms);	10✔
321	return results;	10✔
322	}
323
324	} // end namespace benchmark	99✔

google / benchmark / 1072

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous