Fix histogram memory issues.
Before we had buckets of 5 micro second size. For a 100 MS GC
this used at least 16 * (100 / .005) bytes of storage inside of the
histogram data structure. If you consider the 3 different GC types,
and each timing logger having its own histogram its easy to see
how memory used was significant.
We now have an upper bound on the number of buckets (default 100).
When we hit the upper bound we simply combine adjacent buckets
together. This reduces the total number of buckets by a factor of
2, while increasing the bucket size by a factor of 2. This means
that we may lose a slight amount of precision, but the confidence
intervals remain nearly as useful.
Total unknown memory (occam-svelte):
Before: 45648 kB:
After: 33304 kB
There are probably still some additional optimizations which can be
done as disabling histograms altogether reduces the memory used by
another ~2mB.
A bit of other cleanup in image_space.cc and dlmalloc_space.cc.
Bug: 9967927
Change-Id: I87bb6fe4a3e0e790f104abf3cf07f67677cd7ab3
diff --git a/runtime/base/histogram-inl.h b/runtime/base/histogram-inl.h
index 1a63cf4..0345266 100644
--- a/runtime/base/histogram-inl.h
+++ b/runtime/base/histogram-inl.h
@@ -29,7 +29,7 @@
namespace art {
template <class Value> inline void Histogram<Value>::AddValue(Value value) {
- CHECK_GE(value, 0.0);
+ CHECK_GE(value, static_cast<Value>(0));
if (value >= max_) {
Value new_max = ((value + 1) / bucket_width_ + 1) * bucket_width_;
DCHECK_GT(new_max, max_);
@@ -37,91 +37,90 @@
}
BucketiseValue(value);
- new_values_added_ = true;
}
template <class Value>
-inline Histogram<Value>::Histogram(const std::string name)
+inline Histogram<Value>::Histogram(const char* name, Value initial_bucket_width,
+ size_t max_buckets)
: kAdjust(1000),
- kBucketWidth(5),
- kInitialBucketCount(10),
- bucket_width_(kBucketWidth),
- bucket_count_(kInitialBucketCount) {
- name_ = name;
+ kInitialBucketCount(8),
+ name_(name),
+ max_buckets_(max_buckets),
+ bucket_width_(initial_bucket_width) {
Reset();
}
template <class Value>
inline void Histogram<Value>::GrowBuckets(Value new_max) {
while (max_ < new_max) {
+ // If we have reached the maximum number of buckets, merge buckets together.
+ if (frequency_.size() >= max_buckets_) {
+ CHECK(IsAligned<2>(frequency_.size()));
+ // We double the width of each bucket to reduce the number of buckets by a factor of 2.
+ bucket_width_ *= 2;
+ const size_t limit = frequency_.size() / 2;
+ // Merge the frequencies by adding each adjacent two together.
+ for (size_t i = 0; i < limit; ++i) {
+ frequency_[i] = frequency_[i * 2] + frequency_[i * 2 + 1];
+ }
+ // Remove frequencies in the second half of the array which were added to the first half.
+ while (frequency_.size() > limit) {
+ frequency_.pop_back();
+ }
+ }
max_ += bucket_width_;
- ranges_.push_back(max_);
frequency_.push_back(0);
- bucket_count_++;
}
}
-template <class Value> inline size_t Histogram<Value>::FindBucket(Value val) {
+template <class Value> inline size_t Histogram<Value>::FindBucket(Value val) const {
// Since this is only a linear histogram, bucket index can be found simply with
// dividing the value by the bucket width.
DCHECK_GE(val, min_);
DCHECK_LE(val, max_);
- size_t bucket_idx = static_cast<size_t>(static_cast<double>(val - min_) / bucket_width_);
+ const size_t bucket_idx = static_cast<size_t>((val - min_) / bucket_width_);
DCHECK_GE(bucket_idx, 0ul);
- DCHECK_LE(bucket_idx, bucket_count_);
+ DCHECK_LE(bucket_idx, GetBucketCount());
return bucket_idx;
}
template <class Value>
-inline void Histogram<Value>::BucketiseValue(Value value) {
- CHECK_LT(value, max_);
- sum_ += value;
- sum_of_squares_ += value * value;
- size_t bucket_idx = FindBucket(value);
- sample_size_++;
- if (value > max_value_added_) {
- max_value_added_ = value;
- }
- if (value < min_value_added_) {
- min_value_added_ = value;
- }
- frequency_[bucket_idx]++;
+inline void Histogram<Value>::BucketiseValue(Value val) {
+ CHECK_LT(val, max_);
+ sum_ += val;
+ sum_of_squares_ += val * val;
+ ++sample_size_;
+ ++frequency_[FindBucket(val)];
+ max_value_added_ = std::max(val, max_value_added_);
+ min_value_added_ = std::min(val, min_value_added_);
}
template <class Value> inline void Histogram<Value>::Initialize() {
- DCHECK_GT(bucket_count_, 0ul);
- size_t idx = 0;
- for (; idx < bucket_count_; idx++) {
- ranges_.push_back(min_ + static_cast<Value>(idx) * (bucket_width_));
+ for (size_t idx = 0; idx < kInitialBucketCount; idx++) {
frequency_.push_back(0);
}
// Cumulative frequency and ranges has a length of 1 over frequency.
- ranges_.push_back(min_ + idx * bucket_width_);
- max_ = bucket_width_ * bucket_count_;
+ max_ = bucket_width_ * GetBucketCount();
+}
+
+template <class Value> inline size_t Histogram<Value>::GetBucketCount() const {
+ return frequency_.size();
}
template <class Value> inline void Histogram<Value>::Reset() {
- bucket_width_ = kBucketWidth;
- bucket_count_ = kInitialBucketCount;
- max_ = bucket_width_ * bucket_count_;
sum_of_squares_ = 0;
sample_size_ = 0;
min_ = 0;
sum_ = 0;
min_value_added_ = std::numeric_limits<Value>::max();
max_value_added_ = std::numeric_limits<Value>::min();
- new_values_added_ = false;
- ranges_.clear();
frequency_.clear();
- cumulative_freq_.clear();
- cumulative_perc_.clear();
Initialize();
}
-template <class Value> inline void Histogram<Value>::BuildRanges() {
- for (size_t idx = 0; idx < bucket_count_; ++idx) {
- ranges_.push_back(min_ + idx * bucket_width_);
- }
+template <class Value> inline Value Histogram<Value>::GetRange(size_t bucket_idx) const {
+ DCHECK_LE(bucket_idx, GetBucketCount());
+ return min_ + bucket_idx * bucket_width_;
}
template <class Value> inline double Histogram<Value>::Mean() const {
@@ -143,25 +142,21 @@
}
template <class Value>
-inline void Histogram<Value>::PrintBins(std::ostream &os) {
+inline void Histogram<Value>::PrintBins(std::ostream& os, const CumulativeData& data) const {
DCHECK_GT(sample_size_, 0ull);
- DCHECK(!new_values_added_);
- size_t bin_idx = 0;
- while (bin_idx < cumulative_freq_.size()) {
- if (bin_idx > 0 &&
- cumulative_perc_[bin_idx] == cumulative_perc_[bin_idx - 1]) {
+ for (size_t bin_idx = 0; bin_idx < data.freq_.size(); ++bin_idx) {
+ if (bin_idx > 0 && data.perc_[bin_idx] == data.perc_[bin_idx - 1]) {
bin_idx++;
continue;
}
- os << ranges_[bin_idx] << ": " << cumulative_freq_[bin_idx] << "\t"
- << cumulative_perc_[bin_idx] * 100.0 << "%\n";
- bin_idx++;
+ os << GetRange(bin_idx) << ": " << data.freq_[bin_idx] << "\t"
+ << data.perc_[bin_idx] * 100.0 << "%\n";
}
}
template <class Value>
-inline void Histogram<Value>::PrintConfidenceIntervals(std::ostream &os,
- double interval) const {
+inline void Histogram<Value>::PrintConfidenceIntervals(std::ostream &os, double interval,
+ const CumulativeData& data) const {
DCHECK_GT(interval, 0);
DCHECK_LT(interval, 1.0);
@@ -169,69 +164,51 @@
double per_1 = per_0 + interval;
os << Name() << ":\t";
TimeUnit unit = GetAppropriateTimeUnit(Mean() * kAdjust);
- os << (interval * 100) << "% C.I. "
- << FormatDuration(Percentile(per_0) * kAdjust, unit);
- os << "-" << FormatDuration(Percentile(per_1) * kAdjust, unit) << " ";
+ os << (interval * 100) << "% C.I. " << FormatDuration(Percentile(per_0, data) * kAdjust, unit);
+ os << "-" << FormatDuration(Percentile(per_1, data) * kAdjust, unit) << " ";
os << "Avg: " << FormatDuration(Mean() * kAdjust, unit) << " Max: ";
os << FormatDuration(Max() * kAdjust, unit) << "\n";
}
-template <class Value> inline void Histogram<Value>::BuildCDF() {
- DCHECK_EQ(cumulative_freq_.size(), 0ull);
- DCHECK_EQ(cumulative_perc_.size(), 0ull);
+template <class Value> inline void Histogram<Value>::CreateHistogram(CumulativeData& out_data) {
+ DCHECK_GT(sample_size_, 0ull);
+ out_data.freq_.clear();
+ out_data.perc_.clear();
uint64_t accumulated = 0;
-
- cumulative_freq_.push_back(accumulated);
- cumulative_perc_.push_back(0.0);
+ out_data.freq_.push_back(accumulated);
+ out_data.perc_.push_back(0.0);
for (size_t idx = 0; idx < frequency_.size(); idx++) {
accumulated += frequency_[idx];
- cumulative_freq_.push_back(accumulated);
- cumulative_perc_.push_back(static_cast<double>(accumulated) /
- static_cast<double>(sample_size_));
+ out_data.freq_.push_back(accumulated);
+ out_data.perc_.push_back(static_cast<double>(accumulated) / static_cast<double>(sample_size_));
}
- DCHECK_EQ(*(cumulative_freq_.end() - 1), sample_size_);
- DCHECK_EQ(*(cumulative_perc_.end() - 1), 1.0);
-}
-
-template <class Value> inline void Histogram<Value>::CreateHistogram() {
- DCHECK_GT(sample_size_, 0ull);
-
- // Create a histogram only if new values are added.
- if (!new_values_added_)
- return;
-
- // Reset cumulative values in case this is not the first time creating histogram.
- cumulative_freq_.clear();
- cumulative_perc_.clear();
- BuildCDF();
- new_values_added_ = false;
+ DCHECK_EQ(out_data.freq_.back(), sample_size_);
+ DCHECK_LE(std::abs(out_data.perc_.back() - 1.0), 0.001);
}
template <class Value>
-inline double Histogram<Value>::Percentile(double per) const {
- DCHECK_GT(cumulative_perc_.size(), 0ull);
- size_t idx, upper_idx = 0, lower_idx = 0;
- for (idx = 0; idx < cumulative_perc_.size(); idx++) {
- if (per <= cumulative_perc_[idx]) {
+inline double Histogram<Value>::Percentile(double per, const CumulativeData& data) const {
+ DCHECK_GT(data.perc_.size(), 0ull);
+ size_t upper_idx = 0, lower_idx = 0;
+ for (size_t idx = 0; idx < data.perc_.size(); idx++) {
+ if (per <= data.perc_[idx]) {
upper_idx = idx;
break;
}
- if (per >= cumulative_perc_[idx] && idx != 0 &&
- cumulative_perc_[idx] != cumulative_perc_[idx - 1]) {
+ if (per >= data.perc_[idx] && idx != 0 && data.perc_[idx] != data.perc_[idx - 1]) {
lower_idx = idx;
}
}
- double upper_value = static_cast<double>(ranges_[upper_idx]);
- double lower_value = static_cast<double>(ranges_[lower_idx]);
-
- double lower_perc = cumulative_perc_[lower_idx];
- double upper_perc = cumulative_perc_[upper_idx];
-
+ const double lower_perc = data.perc_[lower_idx];
+ const double lower_value = static_cast<double>(GetRange(lower_idx));
if (per == lower_perc) {
return lower_value;
}
+
+ const double upper_perc = data.perc_[upper_idx];
+ const double upper_value = static_cast<double>(GetRange(upper_idx));
if (per == upper_perc) {
return upper_value;
}
diff --git a/runtime/base/histogram.h b/runtime/base/histogram.h
index 33a1e65..f508af9 100644
--- a/runtime/base/histogram.h
+++ b/runtime/base/histogram.h
@@ -31,19 +31,33 @@
template <class Value> class Histogram {
const double kAdjust;
- const Value kBucketWidth;
const size_t kInitialBucketCount;
public:
- explicit Histogram(std::string);
+ class CumulativeData {
+ friend class Histogram<Value>;
+ std::vector<uint64_t> freq_;
+ std::vector<double> perc_;
+ };
+
+ Histogram(const char* name, Value initial_bucket_width, size_t max_buckets = 100);
void AddValue(Value);
- void CreateHistogram();
+ // Builds the cumulative distribution function from the frequency data.
+ // Accumulative summation of frequencies.
+ // cumulative_freq[i] = sum(frequency[j] : 0 < j < i )
+ // Accumulative summation of percentiles; which is the frequency / SampleSize
+ // cumulative_perc[i] = sum(frequency[j] / SampleSize : 0 < j < i )
+ void CreateHistogram(CumulativeData& data);
+ // Reset the cumulative values, next time CreateHistogram is called it will recreate the cache.
void Reset();
double Mean() const;
double Variance() const;
- double Percentile(double) const;
- void PrintConfidenceIntervals(std::ostream &, double) const;
- void PrintBins(std::ostream &);
+ double Percentile(double per, const CumulativeData& data) const;
+ void PrintConfidenceIntervals(std::ostream& os, double interval,
+ const CumulativeData& data) const;
+ void PrintBins(std::ostream& os, const CumulativeData& data) const;
+ Value GetRange(size_t bucket_idx) const;
+ size_t GetBucketCount() const;
uint64_t SampleSize() const {
return sample_size_;
@@ -61,49 +75,33 @@
return max_value_added_;
}
- const std::string &Name() const {
+ const std::string& Name() const {
return name_;
}
-
private:
- void BuildRanges();
void Initialize();
- size_t FindBucket(Value);
- void BucketiseValue(Value);
- // Builds the cumulative distribution function from the frequency data.
- // Must be called before using the percentile function.
- void BuildCDF();
+ size_t FindBucket(Value val) const;
+ void BucketiseValue(Value val);
// Add more buckets to the histogram to fill in a new value that exceeded
// the max_read_value_.
- void GrowBuckets(Value);
- bool new_values_added_;
+ void GrowBuckets(Value val);
std::string name_;
+ // Maximum number of buckets.
+ const size_t max_buckets_;
// Number of samples placed in histogram.
- uint64_t sample_size_;
+ size_t sample_size_;
// Width of the bucket range. The lower the value is the more accurate
- // histogram percentiles are.
+ // histogram percentiles are. Grows adaptively when we hit max buckets.
Value bucket_width_;
- // Number of bucket to have in the histogram. this value will increase
- // to accommodate for big values that don't fit in initial bucket ranges.
- size_t bucket_count_;
- // Represents the ranges of the histograms. Has SampleSize() + 1 elements
- // e.g. 0,5,10,15 represents ranges 0-5, 5-10, 10-15
- std::vector<Value> ranges_;
- // How many occurrences of values fall within a corresponding range that is
- // saved in the ranges_ vector.
- std::vector<uint64_t> frequency_;
- // Accumulative summation of frequencies.
- // cumulative_freq_[i] = sum(cumulative_freq_[j] : 0 < j < i )
- std::vector<uint64_t> cumulative_freq_;
- // Accumulative summation of percentiles; which is the frequency / SampleSize
- // cumulative_freq_[i] = sum(cumulative_freq_[j] : 0 < j < i )
- std::vector<double> cumulative_perc_;
+ // How many occurrences of values fall within a bucket at index i where i covers the range
+ // starting at min_ + i * bucket_width_ with size bucket_size_.
+ std::vector<uint32_t> frequency_;
// Summation of all the elements inputed by the user.
Value sum_;
- // Maximum value that can fit in the histogram, grows adaptively.
- Value min_;
// Minimum value that can fit in the histogram. Fixed to zero for now.
+ Value min_;
+ // Maximum value that can fit in the histogram, grows adaptively.
Value max_;
// Summation of the values entered. Used to calculate variance.
Value sum_of_squares_;
diff --git a/runtime/base/histogram_test.cc b/runtime/base/histogram_test.cc
index 218c022..534440c 100644
--- a/runtime/base/histogram_test.cc
+++ b/runtime/base/histogram_test.cc
@@ -23,7 +23,7 @@
namespace art {
// Simple usage:
-// Histogram *hist = new Histogram("SimplePercentiles");
+// Histogram *hist(new Histogram("SimplePercentiles"));
// Percentile PerValue
// hist->AddValue(121);
// hist->AddValue(132);
@@ -34,7 +34,7 @@
// PerValue = hist->PercentileVal(0.50); finds the 50th percentile(median).
TEST(Histtest, MeanTest) {
- UniquePtr<Histogram<uint64_t> > hist(new Histogram<uint64_t>("MeanTest"));
+ UniquePtr<Histogram<uint64_t> > hist(new Histogram<uint64_t>("MeanTest", 5));
double mean;
for (size_t Idx = 0; Idx < 90; Idx++) {
@@ -52,20 +52,20 @@
}
TEST(Histtest, VarianceTest) {
- UniquePtr<Histogram<uint64_t> > hist(new Histogram<uint64_t>("VarianceTest"));
+ UniquePtr<Histogram<uint64_t> > hist(new Histogram<uint64_t>("VarianceTest", 5));
double variance;
hist->AddValue(9);
hist->AddValue(17);
hist->AddValue(28);
hist->AddValue(28);
- hist->CreateHistogram();
variance = hist->Variance();
EXPECT_EQ(64.25, variance);
}
TEST(Histtest, Percentile) {
- UniquePtr<Histogram<uint64_t> > hist(new Histogram<uint64_t>("Percentile"));
+ UniquePtr<Histogram<uint64_t> > hist(new Histogram<uint64_t>("Percentile", 5));
+ Histogram<uint64_t>::CumulativeData data;
double PerValue;
@@ -85,13 +85,14 @@
hist->AddValue(145);
hist->AddValue(155);
- hist->CreateHistogram();
- PerValue = hist->Percentile(0.50);
+ hist->CreateHistogram(data);
+ PerValue = hist->Percentile(0.50, data);
EXPECT_EQ(875, static_cast<int>(PerValue * 10));
}
TEST(Histtest, UpdateRange) {
- UniquePtr<Histogram<uint64_t> > hist(new Histogram<uint64_t>("UpdateRange"));
+ UniquePtr<Histogram<uint64_t> > hist(new Histogram<uint64_t>("UpdateRange", 5));
+ Histogram<uint64_t>::CumulativeData data;
double PerValue;
@@ -116,14 +117,13 @@
hist->AddValue(200);
hist->AddValue(205);
hist->AddValue(212);
- hist->CreateHistogram();
- PerValue = hist->Percentile(0.50);
+ hist->CreateHistogram(data);
+ PerValue = hist->Percentile(0.50, data);
std::string text;
std::stringstream stream;
- std::string expected =
- "UpdateRange:\t99% C.I. 15us-212us Avg: 126.380us Max: 212us\n";
- hist->PrintConfidenceIntervals(stream, 0.99);
+ std::string expected("UpdateRange:\t99% C.I. 15us-212us Avg: 126.380us Max: 212us\n");
+ hist->PrintConfidenceIntervals(stream, 0.99, data);
EXPECT_EQ(expected, stream.str());
EXPECT_GE(PerValue, 132);
@@ -131,7 +131,8 @@
}
TEST(Histtest, Reset) {
- UniquePtr<Histogram<uint64_t> > hist(new Histogram<uint64_t>("Reset"));
+ UniquePtr<Histogram<uint64_t> > hist(new Histogram<uint64_t>("Reset", 5));
+ Histogram<uint64_t>::CumulativeData data;
double PerValue;
hist->AddValue(0);
@@ -159,14 +160,13 @@
hist->AddValue(200);
hist->AddValue(205);
hist->AddValue(212);
- hist->CreateHistogram();
- PerValue = hist->Percentile(0.50);
+ hist->CreateHistogram(data);
+ PerValue = hist->Percentile(0.50, data);
std::string text;
std::stringstream stream;
- std::string expected =
- "Reset:\t99% C.I. 15us-212us Avg: 126.380us Max: 212us\n";
- hist->PrintConfidenceIntervals(stream, 0.99);
+ std::string expected("Reset:\t99% C.I. 15us-212us Avg: 126.380us Max: 212us\n");
+ hist->PrintConfidenceIntervals(stream, 0.99, data);
EXPECT_EQ(expected, stream.str());
EXPECT_GE(PerValue, 132);
@@ -174,7 +174,8 @@
}
TEST(Histtest, MultipleCreateHist) {
- UniquePtr<Histogram<uint64_t> > hist(new Histogram<uint64_t>("MultipleCreateHist"));
+ UniquePtr<Histogram<uint64_t> > hist(new Histogram<uint64_t>("MultipleCreateHist", 5));
+ Histogram<uint64_t>::CumulativeData data;
double PerValue;
hist->AddValue(15);
@@ -184,7 +185,7 @@
hist->AddValue(68);
hist->AddValue(75);
hist->AddValue(93);
- hist->CreateHistogram();
+ hist->CreateHistogram(data);
hist->AddValue(110);
hist->AddValue(121);
hist->AddValue(132);
@@ -193,19 +194,18 @@
hist->AddValue(155);
hist->AddValue(163);
hist->AddValue(168);
- hist->CreateHistogram();
+ hist->CreateHistogram(data);
hist->AddValue(175);
hist->AddValue(182);
hist->AddValue(193);
hist->AddValue(200);
hist->AddValue(205);
hist->AddValue(212);
- hist->CreateHistogram();
- PerValue = hist->Percentile(0.50);
+ hist->CreateHistogram(data);
+ PerValue = hist->Percentile(0.50, data);
std::stringstream stream;
- std::string expected =
- "MultipleCreateHist:\t99% C.I. 15us-212us Avg: 126.380us Max: 212us\n";
- hist->PrintConfidenceIntervals(stream, 0.99);
+ std::string expected("MultipleCreateHist:\t99% C.I. 15us-212us Avg: 126.380us Max: 212us\n");
+ hist->PrintConfidenceIntervals(stream, 0.99, data);
EXPECT_EQ(expected, stream.str());
EXPECT_GE(PerValue, 132);
@@ -213,18 +213,20 @@
}
TEST(Histtest, SingleValue) {
- UniquePtr<Histogram<uint64_t> > hist(new Histogram<uint64_t>("SingleValue"));
+ UniquePtr<Histogram<uint64_t> > hist(new Histogram<uint64_t>("SingleValue", 5));
+ Histogram<uint64_t>::CumulativeData data;
hist->AddValue(1);
- hist->CreateHistogram();
+ hist->CreateHistogram(data);
std::stringstream stream;
std::string expected = "SingleValue:\t99% C.I. 1us-1us Avg: 1us Max: 1us\n";
- hist->PrintConfidenceIntervals(stream, 0.99);
+ hist->PrintConfidenceIntervals(stream, 0.99, data);
EXPECT_EQ(expected, stream.str());
}
TEST(Histtest, CappingPercentiles) {
- UniquePtr<Histogram<uint64_t> > hist(new Histogram<uint64_t>("CappingPercentiles"));
+ UniquePtr<Histogram<uint64_t> > hist(new Histogram<uint64_t>("CappingPercentiles", 5));
+ Histogram<uint64_t>::CumulativeData data;
double per_995;
double per_005;
@@ -232,8 +234,8 @@
for (uint64_t idx = 0ull; idx < 150ull; idx++) {
hist->AddValue(0);
}
- hist->CreateHistogram();
- per_995 = hist->Percentile(0.995);
+ hist->CreateHistogram(data);
+ per_995 = hist->Percentile(0.995, data);
EXPECT_EQ(per_995, 0);
hist->Reset();
for (size_t idx = 0; idx < 200; idx++) {
@@ -241,15 +243,16 @@
hist->AddValue(val);
}
}
- hist->CreateHistogram();
- per_005 = hist->Percentile(0.005);
- per_995 = hist->Percentile(0.995);
+ hist->CreateHistogram(data);
+ per_005 = hist->Percentile(0.005, data);
+ per_995 = hist->Percentile(0.995, data);
EXPECT_EQ(1, per_005);
EXPECT_EQ(4, per_995);
}
TEST(Histtest, SpikyValues) {
- UniquePtr<Histogram<uint64_t> > hist(new Histogram<uint64_t>("SpikyValues"));
+ UniquePtr<Histogram<uint64_t> > hist(new Histogram<uint64_t>("SpikyValues", 5, 4096));
+ Histogram<uint64_t>::CumulativeData data;
for (uint64_t idx = 0ull; idx < 30ull; idx++) {
for (uint64_t idx_inner = 0ull; idx_inner < 5ull; idx_inner++) {
@@ -257,11 +260,10 @@
}
}
hist->AddValue(10000);
- hist->CreateHistogram();
+ hist->CreateHistogram(data);
std::stringstream stream;
- std::string expected =
- "SpikyValues:\t99% C.I. 0.089us-2541.825us Avg: 95.033us Max: 10000us\n";
- hist->PrintConfidenceIntervals(stream, 0.99);
+ std::string expected = "SpikyValues:\t99% C.I. 0.089us-2541.825us Avg: 95.033us Max: 10000us\n";
+ hist->PrintConfidenceIntervals(stream, 0.99, data);
EXPECT_EQ(expected, stream.str());
}
diff --git a/runtime/base/timing_logger.cc b/runtime/base/timing_logger.cc
index dfb0220..e2d2d4c 100644
--- a/runtime/base/timing_logger.cc
+++ b/runtime/base/timing_logger.cc
@@ -79,7 +79,8 @@
MutexLock mu(Thread::Current(), lock_);
const std::vector<std::pair<uint64_t, const char*> >& splits = logger.GetSplits();
typedef std::vector<std::pair<uint64_t, const char*> >::const_iterator It;
- if (kIsDebugBuild && splits.size() != histograms_.size()) {
+ // The first time this is run, the histograms array will be empty.
+ if (kIsDebugBuild && !histograms_.empty() && splits.size() != histograms_.size()) {
LOG(ERROR) << "Mismatch in splits.";
typedef std::vector<Histogram<uint64_t> *>::const_iterator It2;
It it = splits.begin();
@@ -111,24 +112,24 @@
void CumulativeLogger::AddPair(const std::string &label, uint64_t delta_time) {
// Convert delta time to microseconds so that we don't overflow our counters.
delta_time /= kAdjust;
- if (index_ >= histograms_.size()) {
- Histogram<uint64_t> *tmp_hist = new Histogram<uint64_t>(label);
- tmp_hist->AddValue(delta_time);
- histograms_.push_back(tmp_hist);
- } else {
- histograms_[index_]->AddValue(delta_time);
- DCHECK_EQ(label, histograms_[index_]->Name());
+ if (histograms_.size() <= index_) {
+ histograms_.push_back(new Histogram<uint64_t>(label.c_str(), 50));
+ DCHECK_GT(histograms_.size(), index_);
}
- index_++;
+ histograms_[index_]->AddValue(delta_time);
+ DCHECK_EQ(label, histograms_[index_]->Name());
+ ++index_;
}
void CumulativeLogger::DumpHistogram(std::ostream &os) {
os << "Start Dumping histograms for " << iterations_ << " iterations"
<< " for " << name_ << "\n";
for (size_t Idx = 0; Idx < histograms_.size(); Idx++) {
- Histogram<uint64_t> &hist = *(histograms_[Idx]);
- hist.CreateHistogram();
- hist.PrintConfidenceIntervals(os, 0.99);
+ Histogram<uint64_t>::CumulativeData cumulative_data;
+ histograms_[Idx]->CreateHistogram(cumulative_data);
+ histograms_[Idx]->PrintConfidenceIntervals(os, 0.99, cumulative_data);
+ // Reset cumulative values to save memory. We don't expect DumpHistogram to be called often, so
+ // it is not performance critical.
}
os << "Done Dumping histograms \n";
}
diff --git a/runtime/gc/space/dlmalloc_space.cc b/runtime/gc/space/dlmalloc_space.cc
index de4917f..a42e880 100644
--- a/runtime/gc/space/dlmalloc_space.cc
+++ b/runtime/gc/space/dlmalloc_space.cc
@@ -131,8 +131,8 @@
size_t bitmap_index = bitmap_index_++;
static const uintptr_t kGcCardSize = static_cast<uintptr_t>(accounting::CardTable::kCardSize);
- CHECK_EQ(reinterpret_cast<uintptr_t>(mem_map->Begin()) % kGcCardSize, 0U);
- CHECK_EQ(reinterpret_cast<uintptr_t>(mem_map->End()) % kGcCardSize, 0U);
+ CHECK(IsAligned<kGcCardSize>(reinterpret_cast<uintptr_t>(mem_map->Begin())));
+ CHECK(IsAligned<kGcCardSize>(reinterpret_cast<uintptr_t>(mem_map->End())));
live_bitmap_.reset(accounting::SpaceBitmap::Create(
StringPrintf("allocspace %s live-bitmap %d", name.c_str(), static_cast<int>(bitmap_index)),
Begin(), Capacity()));
diff --git a/runtime/gc/space/image_space.cc b/runtime/gc/space/image_space.cc
index 4862c0a..8ff7025 100644
--- a/runtime/gc/space/image_space.cc
+++ b/runtime/gc/space/image_space.cc
@@ -56,7 +56,7 @@
std::vector<std::string> arg_vector;
- std::string dex2oat = GetAndroidRoot();
+ std::string dex2oat(GetAndroidRoot());
dex2oat += (kIsDebugBuild ? "/bin/dex2oatd" : "/bin/dex2oat");
arg_vector.push_back(dex2oat);