blob: dffd70363a415c70324d8d4691ec9fb1eb8da4fe [file] [log] [blame]
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/metrics/histogram_samples.h"
#include <limits>
#include "base/compiler_specific.h"
#include "base/metrics/histogram_functions.h"
#include "base/metrics/histogram_macros.h"
#include "base/numerics/safe_conversions.h"
#include "base/numerics/safe_math.h"
#include "base/pickle.h"
#include "starboard/memory.h"
namespace base {
namespace {
// A shorthand constant for the max value of size_t.
constexpr size_t kSizeMax = std::numeric_limits<size_t>::max();
// A constant stored in an AtomicSingleSample (as_atomic) to indicate that the
// sample is "disabled" and no further accumulation should be done with it. The
// value is chosen such that it will be MAX_UINT16 for both |bucket| & |count|,
// and thus less likely to conflict with real use. Conflicts are explicitly
// handled in the code but it's worth making them as unlikely as possible.
constexpr int32_t kDisabledSingleSample = -1;
class SampleCountPickleIterator : public SampleCountIterator {
explicit SampleCountPickleIterator(PickleIterator* iter);
bool Done() const override;
void Next() override;
void Get(HistogramBase::Sample* min,
int64_t* max,
HistogramBase::Count* count) const override;
PickleIterator* const iter_;
HistogramBase::Sample min_;
int64_t max_;
HistogramBase::Count count_;
bool is_done_;
SampleCountPickleIterator::SampleCountPickleIterator(PickleIterator* iter)
: iter_(iter),
is_done_(false) {
bool SampleCountPickleIterator::Done() const {
return is_done_;
void SampleCountPickleIterator::Next() {
if (!iter_->ReadInt(&min_) || !iter_->ReadInt64(&max_) ||
!iter_->ReadInt(&count_)) {
is_done_ = true;
void SampleCountPickleIterator::Get(HistogramBase::Sample* min,
int64_t* max,
HistogramBase::Count* count) const {
*min = min_;
*max = max_;
*count = count_;
} // namespace
static_assert(sizeof(HistogramSamples::AtomicSingleSample) ==
"AtomicSingleSample isn't 32 bits");
HistogramSamples::SingleSample HistogramSamples::AtomicSingleSample::Load()
const {
AtomicSingleSample single_sample = subtle::Acquire_Load(&as_atomic);
// If the sample was extracted/disabled, it's still zero to the outside.
if (single_sample.as_atomic == kDisabledSingleSample)
single_sample.as_atomic = 0;
return single_sample.as_parts;
HistogramSamples::SingleSample HistogramSamples::AtomicSingleSample::Extract(
bool disable) {
AtomicSingleSample single_sample = subtle::NoBarrier_AtomicExchange(
&as_atomic, disable ? kDisabledSingleSample : 0);
if (single_sample.as_atomic == kDisabledSingleSample)
single_sample.as_atomic = 0;
return single_sample.as_parts;
bool HistogramSamples::AtomicSingleSample::Accumulate(
size_t bucket,
HistogramBase::Count count) {
if (count == 0)
return true;
// Convert the parameters to 16-bit variables because it's all 16-bit below.
// To support decrements/subtractions, divide the |count| into sign/value and
// do the proper operation below. The alternative is to change the single-
// sample's count to be a signed integer (int16_t) and just add an int16_t
// |count16| but that is somewhat wasteful given that the single-sample is
// never expected to have a count less than zero.
if (count < -std::numeric_limits<uint16_t>::max() ||
count > std::numeric_limits<uint16_t>::max() ||
bucket > std::numeric_limits<uint16_t>::max()) {
return false;
bool count_is_negative = count < 0;
uint16_t count16 = static_cast<uint16_t>(count_is_negative ? -count : count);
uint16_t bucket16 = static_cast<uint16_t>(bucket);
// A local, unshared copy of the single-sample is necessary so the parts
// can be manipulated without worrying about atomicity.
AtomicSingleSample single_sample;
bool sample_updated;
do {
subtle::Atomic32 original = subtle::Acquire_Load(&as_atomic);
if (original == kDisabledSingleSample)
return false;
single_sample.as_atomic = original;
if (single_sample.as_atomic != 0) {
// Only the same bucket (parameter and stored) can be counted multiple
// times.
if (single_sample.as_parts.bucket != bucket16)
return false;
} else {
// The |single_ sample| was zero so becomes the |bucket| parameter, the
// contents of which were checked above to fit in 16 bits.
single_sample.as_parts.bucket = bucket16;
// Update count, making sure that it doesn't overflow.
CheckedNumeric<uint16_t> new_count(single_sample.as_parts.count);
if (count_is_negative)
new_count -= count16;
new_count += count16;
if (!new_count.AssignIfValid(&single_sample.as_parts.count))
return false;
// Don't let this become equivalent to the "disabled" value.
if (single_sample.as_atomic == kDisabledSingleSample)
return false;
// Store the updated single-sample back into memory. |existing| is what
// was in that memory location at the time of the call; if it doesn't
// match |original| then the swap didn't happen so loop again.
subtle::Atomic32 existing = subtle::Release_CompareAndSwap(
&as_atomic, original, single_sample.as_atomic);
sample_updated = (existing == original);
} while (!sample_updated);
return true;
bool HistogramSamples::AtomicSingleSample::IsDisabled() const {
return subtle::Acquire_Load(&as_atomic) == kDisabledSingleSample;
HistogramSamples::LocalMetadata::LocalMetadata() {
// This is the same way it's done for persistent metadata since no ctor
// is called for the data members in that case.
memset(this, 0, sizeof(*this));
HistogramSamples::HistogramSamples(uint64_t id, Metadata* meta)
: meta_(meta) {
DCHECK(meta_->id == 0 || meta_->id == id);
// It's possible that |meta| is contained in initialized, read-only memory
// so it's essential that no write be done in that case.
if (!meta_->id)
meta_->id = id;
// This mustn't do anything with |meta_|. It was passed to the ctor and may
// be invalid by the time this dtor gets called.
HistogramSamples::~HistogramSamples() = default;
void HistogramSamples::Add(const HistogramSamples& other) {
IncreaseSumAndCount(other.sum(), other.redundant_count());
std::unique_ptr<SampleCountIterator> it = other.Iterator();
bool success = AddSubtractImpl(it.get(), ADD);
bool HistogramSamples::AddFromPickle(PickleIterator* iter) {
int64_t sum;
HistogramBase::Count redundant_count;
if (!iter->ReadInt64(&sum) || !iter->ReadInt(&redundant_count))
return false;
IncreaseSumAndCount(sum, redundant_count);
SampleCountPickleIterator pickle_iter(iter);
return AddSubtractImpl(&pickle_iter, ADD);
void HistogramSamples::Subtract(const HistogramSamples& other) {
IncreaseSumAndCount(-other.sum(), -other.redundant_count());
std::unique_ptr<SampleCountIterator> it = other.Iterator();
bool success = AddSubtractImpl(it.get(), SUBTRACT);
void HistogramSamples::Serialize(Pickle* pickle) const {
HistogramBase::Sample min;
int64_t max;
HistogramBase::Count count;
for (std::unique_ptr<SampleCountIterator> it = Iterator(); !it->Done();
it->Next()) {
it->Get(&min, &max, &count);
bool HistogramSamples::AccumulateSingleSample(HistogramBase::Sample value,
HistogramBase::Count count,
size_t bucket) {
if (single_sample().Accumulate(bucket, count)) {
// Success. Update the (separate) sum and redundant-count.
IncreaseSumAndCount(strict_cast<int64_t>(value) * count, count);
return true;
return false;
void HistogramSamples::IncreaseSumAndCount(int64_t sum,
HistogramBase::Count count) {
#ifdef ARCH_CPU_64_BITS
subtle::NoBarrier_AtomicIncrement(&meta_->sum, sum);
meta_->sum += sum;
subtle::NoBarrier_AtomicIncrement(&meta_->redundant_count, count);
void HistogramSamples::RecordNegativeSample(NegativeSampleReason reason,
HistogramBase::Count increment) {
UMA_HISTOGRAM_ENUMERATION("UMA.NegativeSamples.Reason", reason,
UMA_HISTOGRAM_CUSTOM_COUNTS("UMA.NegativeSamples.Increment", increment, 1,
1 << 30, 100);
SampleCountIterator::~SampleCountIterator() = default;
bool SampleCountIterator::GetBucketIndex(size_t* index) const {
return false;
SingleSampleIterator::SingleSampleIterator(HistogramBase::Sample min,
int64_t max,
HistogramBase::Count count)
: SingleSampleIterator(min, max, count, kSizeMax) {}
SingleSampleIterator::SingleSampleIterator(HistogramBase::Sample min,
int64_t max,
HistogramBase::Count count,
size_t bucket_index)
: min_(min), max_(max), bucket_index_(bucket_index), count_(count) {}
SingleSampleIterator::~SingleSampleIterator() = default;
bool SingleSampleIterator::Done() const {
return count_ == 0;
void SingleSampleIterator::Next() {
count_ = 0;
void SingleSampleIterator::Get(HistogramBase::Sample* min,
int64_t* max,
HistogramBase::Count* count) const {
if (min != nullptr)
*min = min_;
if (max != nullptr)
*max = max_;
if (count != nullptr)
*count = count_;
bool SingleSampleIterator::GetBucketIndex(size_t* index) const {
if (bucket_index_ == kSizeMax)
return false;
*index = bucket_index_;
return true;
} // namespace base