proxygen: folly::BucketedTimeSeries< VT, CT

#include <BucketedTimeSeries.h>

Public Types
using	ValueType = VT

using	Clock = CT

using	Duration = typename Clock::duration

using	TimePoint = typename Clock::time_point

using	Bucket = detail::Bucket< ValueType >

Public Member Functions
	BucketedTimeSeries (size_t numBuckets, Duration duration)

	BucketedTimeSeries (TimePoint theFirstTime, TimePoint theLatestTime, Duration maxDuration, const std::vector< Bucket > &bucketsList)

bool	addValue (TimePoint now, const ValueType &val)

bool	addValue (TimePoint now, const ValueType &val, uint64_t times)

bool	addValueAggregated (TimePoint now, const ValueType &total, uint64_t nsamples)

size_t	update (TimePoint now)

void	clear ()

TimePoint	getLatestTime () const

TimePoint	getEarliestTime () const

size_t	numBuckets () const

Duration	duration () const

bool	isAllTime () const

bool	empty () const

TimePoint	firstTime () const

TimePoint	latestTime () const

const std::vector< Bucket > &	buckets () const

Duration	elapsed () const

Duration	elapsed (TimePoint start, TimePoint end) const

const ValueType &	sum () const

uint64_t	count () const

template<typename ReturnType = double>
ReturnType	avg () const

template<typename ReturnType = double, typename Interval = Duration>
ReturnType	rate () const

template<typename ReturnType = double, typename Interval = Duration>
ReturnType	countRate () const

ValueType	sum (TimePoint start, TimePoint end) const

uint64_t	count (TimePoint start, TimePoint end) const

template<typename ReturnType = double>
ReturnType	avg (TimePoint start, TimePoint end) const

template<typename ReturnType = double, typename Interval = Duration>
ReturnType	rate (TimePoint start, TimePoint end) const

template<typename ReturnType = double, typename Interval = Duration>
ReturnType	countRate (TimePoint start, TimePoint end) const

template<typename Function >
void	forEachBucket (Function fn) const

size_t	getBucketIdx (TimePoint time) const

const Bucket &	getBucketByIndex (size_t idx) const

void	getBucketInfo (TimePoint time, size_t bucketIdx, TimePoint bucketStart, TimePoint *nextBucketStart) const

bool	addValue (Duration now, const ValueType &val)

bool	addValue (Duration now, const ValueType &val, uint64_t times)

bool	addValueAggregated (Duration now, const ValueType &total, uint64_t nsamples)

size_t	update (Duration now)

Private Member Functions
template<typename ReturnType = double, typename Interval = Duration>
ReturnType	rateHelper (ReturnType numerator, Duration elapsedTime) const

TimePoint	getEarliestTimeNonEmpty () const

size_t	updateBuckets (TimePoint now)

ValueType	rangeAdjust (TimePoint bucketStart, TimePoint nextBucketStart, TimePoint start, TimePoint end, ValueType input) const

template<typename Function >
void	forEachBucket (TimePoint start, TimePoint end, Function fn) const

Private Attributes
TimePoint	firstTime_

TimePoint	latestTime_

Duration	duration_

Bucket	total_

std::vector< Bucket >	buckets_

Detailed Description

template<typename VT, typename CT = LegacyStatsClock<std::chrono::seconds>>
class folly::BucketedTimeSeries< VT, CT >

Definition at line 64 of file BucketedTimeSeries.h.

Member Typedef Documentation

template<typename VT, typename CT = LegacyStatsClock<std::chrono::seconds>>

using folly::BucketedTimeSeries< VT, CT >::Bucket = detail::Bucket<ValueType>

Definition at line 70 of file BucketedTimeSeries.h.

template<typename VT, typename CT = LegacyStatsClock<std::chrono::seconds>>

using folly::BucketedTimeSeries< VT, CT >::Clock = CT

Definition at line 67 of file BucketedTimeSeries.h.

template<typename VT, typename CT = LegacyStatsClock<std::chrono::seconds>>

using folly::BucketedTimeSeries< VT, CT >::Duration = typename Clock::duration

Definition at line 68 of file BucketedTimeSeries.h.

template<typename VT, typename CT = LegacyStatsClock<std::chrono::seconds>>

using folly::BucketedTimeSeries< VT, CT >::TimePoint = typename Clock::time_point

Definition at line 69 of file BucketedTimeSeries.h.

template<typename VT, typename CT = LegacyStatsClock<std::chrono::seconds>>

using folly::BucketedTimeSeries< VT, CT >::ValueType = VT

Definition at line 66 of file BucketedTimeSeries.h.

Constructor & Destructor Documentation

template<typename VT , typename CT >

folly::BucketedTimeSeries< VT, CT >::BucketedTimeSeries	(	size_t	numBuckets,
		Duration	duration
	)

Definition at line 28 of file BucketedTimeSeries-defs.h.

References folly::BucketedTimeSeries< VT, CT >::buckets_, folly::BucketedTimeSeries< VT, CT >::duration_, and folly::BucketedTimeSeries< VT, CT >::isAllTime().

     : firstTime_(Duration(1)), latestTime_(), duration_(maxDuration) {
   // For tracking all-time data we only use total_, and don't need to bother
   // with buckets_
   if (!isAllTime()) {
     // Round nBuckets down to duration_.count().
     //
     // There is no point in having more buckets than our timestamp
     // granularity: otherwise we would have buckets that could never be used.
     if (nBuckets > size_t(duration_.count())) {
       nBuckets = size_t(duration_.count());
     }
 
     buckets_.resize(nBuckets, Bucket());
   }
 }

template<typename VT , typename CT >

folly::BucketedTimeSeries< VT, CT >::BucketedTimeSeries	(	TimePoint	theFirstTime,
		TimePoint	theLatestTime,
		Duration	maxDuration,
		const std::vector< Bucket > &	bucketsList
	)

Definition at line 48 of file BucketedTimeSeries-defs.h.

References folly::detail::Bucket< T >::add(), folly::BucketedTimeSeries< VT, CT >::buckets_, folly::detail::Bucket< T >::count, folly::BucketedTimeSeries< VT, CT >::duration_, folly::BucketedTimeSeries< VT, CT >::firstTime_, folly::BucketedTimeSeries< VT, CT >::latestTime_, folly::detail::Bucket< T >::sum, and folly::BucketedTimeSeries< VT, CT >::total_.

     : firstTime_(theFirstTime),
       latestTime_(theLatestTime),
       duration_(maxDuration),
       buckets_(bucketsList) {
   // Come up with the total_ from buckets_ being passed in
   for (auto const& bucket : buckets_) {
     total_.add(bucket.sum, bucket.count);
   }
 
   // Verify the integrity of the data
 
   // If firstTime is greater than latestTime, the total count should be 0.
   // (firstTime being greater than latestTime means that no data points have
   // ever been added to the time series.)
   if (firstTime_ > latestTime_ && (total_.sum != 0 || total_.count != 0)) {
     throw std::invalid_argument(
         "The total should have been 0 "
         "if firstTime is greater than lastestTime");
   }
 
   // If firstTime is less than or equal to latestTime,
   // latestTime - firstTime should be less than or equal to the duration.
   if (firstTime_ <= latestTime_ && latestTime_ - firstTime_ > duration_) {
     throw std::invalid_argument(
         "The difference between firstTime and latestTime "
         "should be less than or equal to the duration");
   }
 }

Member Function Documentation

template<typename VT , typename CT >

bool folly::BucketedTimeSeries< VT, CT >::addValue	(	TimePoint	now,
		const ValueType &	val
	)

Definition at line 83 of file BucketedTimeSeries-defs.h.

References folly::BucketedTimeSeries< VT, CT >::addValueAggregated().

Referenced by addValue(), TEST(), and testUpdate100x10().

                                                                              {
   return addValueAggregated(now, val, 1);
 }

template<typename VT , typename CT >

bool folly::BucketedTimeSeries< VT, CT >::addValue	(	TimePoint	now,
		const ValueType &	val,
		uint64_t	times
	)

Definition at line 88 of file BucketedTimeSeries-defs.h.

References folly::BucketedTimeSeries< VT, CT >::addValueAggregated().

                     {
   return addValueAggregated(now, val * ValueType(times), times);
 }

template<typename VT, typename CT = LegacyStatsClock<std::chrono::seconds>>

bool folly::BucketedTimeSeries< VT, CT >::addValue	(	Duration	now,
		const ValueType &	val
	)

inline

Definition at line 448 of file BucketedTimeSeries.h.

                                                     {
     return addValueAggregated(TimePoint(now), val, 1);
   }

template<typename VT, typename CT = LegacyStatsClock<std::chrono::seconds>>

bool folly::BucketedTimeSeries< VT, CT >::addValue	(	Duration	now,
		const ValueType &	val,
		uint64_t	times
	)

inline

Definition at line 451 of file BucketedTimeSeries.h.

                                                                     {
     return addValueAggregated(TimePoint(now), val * ValueType(times), times);
   }

template<typename VT , typename CT >

bool folly::BucketedTimeSeries< VT, CT >::addValueAggregated	(	TimePoint	now,
		const ValueType &	total,
		uint64_t	nsamples
	)

Definition at line 96 of file BucketedTimeSeries-defs.h.

Referenced by folly::BucketedTimeSeries< VT, CT >::addValue(), and TEST().

                        {
   if (isAllTime()) {
     if (UNLIKELY(empty())) {
       firstTime_ = now;
       latestTime_ = now;
     } else if (now > latestTime_) {
       latestTime_ = now;
     } else if (now < firstTime_) {
       firstTime_ = now;
     }
     total_.add(total, nsamples);
     return true;
   }
 
   size_t bucketIdx;
   if (UNLIKELY(empty())) {
     // First data point we've ever seen
     firstTime_ = now;
     latestTime_ = now;
     bucketIdx = getBucketIdx(now);
   } else if (now > latestTime_) {
     // More recent time.  Need to update the buckets.
     bucketIdx = updateBuckets(now);
   } else if (LIKELY(now == latestTime_)) {
     // Current time.
     bucketIdx = getBucketIdx(now);
   } else {
     // An earlier time in the past.  We need to check if this time still falls
     // within our window.
     if (now < getEarliestTimeNonEmpty()) {
       return false;
     }
     bucketIdx = getBucketIdx(now);
   }
 
   total_.add(total, nsamples);
   buckets_[bucketIdx].add(total, nsamples);
   return true;
 }

template<typename VT, typename CT = LegacyStatsClock<std::chrono::seconds>>

bool folly::BucketedTimeSeries< VT, CT >::addValueAggregated	(	Duration	now,
		const ValueType &	total,
		uint64_t	nsamples
	)

inline

Definition at line 455 of file BucketedTimeSeries.h.

                                                                               {
     return addValueAggregated(TimePoint(now), total, nsamples);
   }

template<typename VT, typename CT = LegacyStatsClock<std::chrono::seconds>>

template<typename ReturnType = double>

ReturnType folly::BucketedTimeSeries< VT, CT >::avg ( ) const

inline

Definition at line 297 of file BucketedTimeSeries.h.

Referenced by TEST(), and testUpdate100x10().

                          {
     return total_.template avg<ReturnType>();
   }

template<typename VT , typename CT >

template<typename ReturnType >

ReturnType folly::BucketedTimeSeries< VT, CT >::avg	(	TimePoint	start,
		TimePoint	end
	)		const

Definition at line 317 of file BucketedTimeSeries-defs.h.

References folly::detail::Bucket< T >::count, folly::BucketedTimeSeries< VT, CT >::forEachBucket(), folly::BucketedTimeSeries< VT, CT >::rangeAdjust(), folly::detail::Bucket< T >::sum, and uint64_t.

           {
   ValueType total = ValueType();
   uint64_t sample_count = 0;
   forEachBucket(
       start,
       end,
       [&](const Bucket& bucket,
           TimePoint bucketStart,
           TimePoint nextBucketStart) -> bool {
         total += this->rangeAdjust(
             bucketStart, nextBucketStart, start, end, bucket.sum);
         sample_count += this->rangeAdjust(
             bucketStart, nextBucketStart, start, end, ValueType(bucket.count));
         return true;
       });
 
   if (sample_count == 0) {
     return ReturnType(0);
   }
 
   return detail::avgHelper<ReturnType>(total, sample_count);
 }

template<typename VT, typename CT = LegacyStatsClock<std::chrono::seconds>>

const std::vector<Bucket>& folly::BucketedTimeSeries< VT, CT >::buckets ( ) const

inline

Definition at line 226 of file BucketedTimeSeries.h.

References folly::test::end(), and start.

Referenced by TEST().

                                            {
     return buckets_;
   }

template<typename VT , typename CT >

void folly::BucketedTimeSeries< VT, CT >::clear ( )

Definition at line 214 of file BucketedTimeSeries-defs.h.

References folly::BucketedTimeSeries< VT, CT >::buckets_, folly::detail::Bucket< T >::clear(), folly::BucketedTimeSeries< VT, CT >::firstTime_, folly::BucketedTimeSeries< VT, CT >::latestTime_, and folly::BucketedTimeSeries< VT, CT >::total_.

Referenced by TEST(), and testUpdate100x10().

                                        {
   for (Bucket& bucket : buckets_) {
     bucket.clear();
   }
   total_.clear();
   // Set firstTime_ larger than latestTime_,
   // to indicate that the timeseries is empty
   firstTime_ = TimePoint(Duration(1));
   latestTime_ = TimePoint();
 }

template<typename VT, typename CT = LegacyStatsClock<std::chrono::seconds>>

uint64_t folly::BucketedTimeSeries< VT, CT >::count ( ) const

inline

Definition at line 283 of file BucketedTimeSeries.h.

Referenced by folly::MultiLevelTimeSeries< VT, CT >::count(), folly::MultiLevelTimeSeries< VT, CT >::getLevel(), TEST(), and testUpdate100x10().

                          {
     return total_.count;
   }

template<typename VT , typename CT >

uint64_t folly::BucketedTimeSeries< VT, CT >::count	(	TimePoint	start,
		TimePoint	end
	)		const

Definition at line 298 of file BucketedTimeSeries-defs.h.

References folly::detail::Bucket< T >::count, folly::BucketedTimeSeries< VT, CT >::forEachBucket(), folly::BucketedTimeSeries< VT, CT >::rangeAdjust(), and uint64_t.

           {
   uint64_t sample_count = 0;
   forEachBucket(
       start,
       end,
       [&](const Bucket& bucket,
           TimePoint bucketStart,
           TimePoint nextBucketStart) -> bool {
         sample_count += this->rangeAdjust(
             bucketStart, nextBucketStart, start, end, ValueType(bucket.count));
         return true;
       });
 
   return sample_count;
 }

template<typename VT, typename CT = LegacyStatsClock<std::chrono::seconds>>

template<typename ReturnType = double, typename Interval = Duration>

ReturnType folly::BucketedTimeSeries< VT, CT >::countRate ( ) const

inline

Definition at line 325 of file BucketedTimeSeries.h.

References count, sum(), and uint64_t.

Referenced by TEST().

                                {
     return rateHelper<ReturnType, Interval>(
         ReturnType(total_.count), elapsed());
   }

template<typename VT, typename CT = LegacyStatsClock<std::chrono::seconds>>

template<typename ReturnType = double, typename Interval = Duration>

ReturnType folly::BucketedTimeSeries< VT, CT >::countRate	(	TimePoint	start,
		TimePoint	end
	)		const

inline

Definition at line 385 of file BucketedTimeSeries.h.

References count, folly::detail::distributed_mutex::time(), and uint64_t.

                                                              {
     uint64_t intervalCount = count(start, end);
     Duration interval = elapsed(start, end);
     return rateHelper<ReturnType, Interval>(
         ReturnType(intervalCount), interval);
   }

template<typename VT, typename CT = LegacyStatsClock<std::chrono::seconds>>

Duration folly::BucketedTimeSeries< VT, CT >::duration ( ) const

inline

Definition at line 182 of file BucketedTimeSeries.h.

Referenced by TEST().

                             {
     return duration_;
   }

template<typename VT , typename CT >

CT::duration folly::BucketedTimeSeries< VT, CT >::elapsed ( ) const

Definition at line 258 of file BucketedTimeSeries-defs.h.

References folly::BucketedTimeSeries< VT, CT >::empty(), folly::BucketedTimeSeries< VT, CT >::getEarliestTime(), and folly::BucketedTimeSeries< VT, CT >::latestTime_.

Referenced by TEST().

                                                               {
   if (empty()) {
     return Duration(0);
   }
 
   // Add 1 since [latestTime_, earliestTime] is an inclusive interval.
   return latestTime_ - getEarliestTime() + Duration(1);
 }

template<typename VT , typename CT >

CT::duration folly::BucketedTimeSeries< VT, CT >::elapsed	(	TimePoint	start,
		TimePoint	end
	)		const

Definition at line 268 of file BucketedTimeSeries-defs.h.

References folly::BucketedTimeSeries< VT, CT >::empty(), folly::BucketedTimeSeries< VT, CT >::getEarliestTime(), folly::BucketedTimeSeries< VT, CT >::latestTime_, max, min, and start.

                          {
   if (empty()) {
     return Duration(0);
   }
   start = std::max(start, getEarliestTime());
   end = std::min(end, latestTime_ + Duration(1));
   end = std::max(start, end);
   return end - start;
 }

template<typename VT, typename CT = LegacyStatsClock<std::chrono::seconds>>

bool folly::BucketedTimeSeries< VT, CT >::empty ( ) const

inline

Definition at line 198 of file BucketedTimeSeries.h.

Referenced by folly::BucketedTimeSeries< VT, CT >::addValueAggregated(), folly::BucketedTimeSeries< VT, CT >::elapsed(), folly::BucketedTimeSeries< VT, CT >::getEarliestTime(), and folly::BucketedTimeSeries< VT, CT >::update().

                      {
     // We set firstTime_ greater than latestTime_ in the constructor and in
     // clear, so we use this to distinguish if the timeseries is empty.
     //
     // Once a data point has been added, latestTime_ will always be greater
     // than or equal to firstTime_.
     return firstTime_ > latestTime_;
   }

template<typename VT, typename CT = LegacyStatsClock<std::chrono::seconds>>

TimePoint folly::BucketedTimeSeries< VT, CT >::firstTime ( ) const

inline

Definition at line 211 of file BucketedTimeSeries.h.

Referenced by TEST().

                               {
     return firstTime_;
   }

template<typename VT , typename CT >

template<typename Function >

void folly::BucketedTimeSeries< VT, CT >::forEachBucket ( Function fn ) const

Definition at line 407 of file BucketedTimeSeries-defs.h.

References folly::BucketedTimeSeries< VT, CT >::buckets_, folly::BucketedTimeSeries< VT, CT >::duration_, folly::BucketedTimeSeries< VT, CT >::firstTime_, folly::BucketedTimeSeries< VT, CT >::isAllTime(), folly::BucketedTimeSeries< VT, CT >::latestTime_, and folly::BucketedTimeSeries< VT, CT >::total_.

Referenced by folly::BucketedTimeSeries< VT, CT >::avg(), folly::BucketedTimeSeries< VT, CT >::count(), folly::BucketedTimeSeries< VT, CT >::forEachBucket(), folly::BucketedTimeSeries< VT, CT >::sum(), and TEST().

                                                                 {
   if (isAllTime()) {
     fn(total_, firstTime_, latestTime_ + Duration(1));
     return;
   }
 
   typedef typename Duration::rep TimeInt;
 
   // Compute durationStart, latestBucketIdx, and scaledNextBucketStart,
   // the same way as in getBucketInfo().
   Duration timeMod = latestTime_.time_since_epoch() % duration_;
   TimeInt numFullDurations = latestTime_.time_since_epoch() / duration_;
   TimePoint durationStart(numFullDurations * duration_);
   TimeInt scaledTime = timeMod.count() * TimeInt(buckets_.size());
   size_t latestBucketIdx = size_t(scaledTime / duration_.count());
   TimeInt scaledOffsetInBucket = scaledTime % duration_.count();
   TimeInt scaledBucketStart = scaledTime - scaledOffsetInBucket;
   TimeInt scaledNextBucketStart = scaledBucketStart + duration_.count();
 
   // Walk through the buckets, starting one past the current bucket.
   // The next bucket is from the previous cycle, so subtract 1 duration
   // from durationStart.
   size_t idx = latestBucketIdx;
   durationStart -= duration_;
 
   TimePoint nextBucketStart =
       Duration(
           (scaledNextBucketStart + buckets_.size() - 1) / buckets_.size()) +
       durationStart;
   while (true) {
     ++idx;
     if (idx >= buckets_.size()) {
       idx = 0;
       durationStart += duration_;
       scaledNextBucketStart = duration_.count();
     } else {
       scaledNextBucketStart += duration_.count();
     }
 
     TimePoint bucketStart = nextBucketStart;
     nextBucketStart =
         Duration(
             (scaledNextBucketStart + buckets_.size() - 1) / buckets_.size()) +
         durationStart;
 
     // Should we bother skipping buckets where firstTime_ >= nextBucketStart?
     // For now we go ahead and invoke the function with these buckets.
     // sum and count should always be 0 in these buckets.
 
     DCHECK_LE(
         bucketStart.time_since_epoch().count(),
         latestTime_.time_since_epoch().count());
     bool ret = fn(buckets_[idx], bucketStart, nextBucketStart);
     if (!ret) {
       break;
     }
 
     if (idx == latestBucketIdx) {
       // all done
       break;
     }
   }
 }

template<typename VT , typename CT >

template<typename Function >

void folly::BucketedTimeSeries< VT, CT >::forEachBucket	(	TimePoint	start,
		TimePoint	end,
		Function	fn
	)		const

private

Definition at line 508 of file BucketedTimeSeries-defs.h.

References folly::BucketedTimeSeries< VT, CT >::forEachBucket().

                        {
   forEachBucket(
       [&start, &end, &fn](
           const Bucket& bucket,
           TimePoint bucketStart,
           TimePoint nextBucketStart) -> bool {
         if (start >= nextBucketStart) {
           return true;
         }
         if (end <= bucketStart) {
           return false;
         }
         bool ret = fn(bucket, bucketStart, nextBucketStart);
         return ret;
       });
 }

template<typename VT, typename CT = LegacyStatsClock<std::chrono::seconds>>

const Bucket& folly::BucketedTimeSeries< VT, CT >::getBucketByIndex ( size_t idx ) const

inline

Definition at line 425 of file BucketedTimeSeries.h.

Referenced by TEST().

                                                    {
     return buckets_[idx];
   }

template<typename VT , typename CT >

size_t folly::BucketedTimeSeries< VT, CT >::getBucketIdx ( TimePoint time ) const

Definition at line 359 of file BucketedTimeSeries-defs.h.

References folly::BucketedTimeSeries< VT, CT >::buckets_, folly::BucketedTimeSeries< VT, CT >::duration_, and folly::BucketedTimeSeries< VT, CT >::isAllTime().

Referenced by folly::BucketedTimeSeries< VT, CT >::addValueAggregated(), TEST(), folly::BucketedTimeSeries< VT, CT >::update(), and folly::BucketedTimeSeries< VT, CT >::updateBuckets().

                                                                     {
   // For all-time data we don't use buckets_.  Everything is tracked in total_.
   DCHECK(!isAllTime());
 
   auto timeIntoCurrentCycle = (time.time_since_epoch() % duration_);
   return timeIntoCurrentCycle.count() * buckets_.size() / duration_.count();
 }

template<typename VT , typename CT >

void folly::BucketedTimeSeries< VT, CT >::getBucketInfo	(	TimePoint	time,
		size_t *	bucketIdx,
		TimePoint *	bucketStart,
		TimePoint *	nextBucketStart
	)		const

Definition at line 372 of file BucketedTimeSeries-defs.h.

References folly::BucketedTimeSeries< VT, CT >::buckets_, folly::BucketedTimeSeries< VT, CT >::duration_, and folly::BucketedTimeSeries< VT, CT >::isAllTime().

Referenced by folly::BucketedTimeSeries< VT, CT >::getEarliestTimeNonEmpty(), TEST(), and folly::BucketedTimeSeries< VT, CT >::updateBuckets().

                                       {
   typedef typename Duration::rep TimeInt;
   DCHECK(!isAllTime());
 
   // Keep these two lines together.  The compiler should be able to compute
   // both the division and modulus with a single operation.
   Duration timeMod = time.time_since_epoch() % duration_;
   TimeInt numFullDurations = time.time_since_epoch() / duration_;
 
   TimeInt scaledTime = timeMod.count() * TimeInt(buckets_.size());
 
   // Keep these two lines together.  The compiler should be able to compute
   // both the division and modulus with a single operation.
   *bucketIdx = size_t(scaledTime / duration_.count());
   TimeInt scaledOffsetInBucket = scaledTime % duration_.count();
 
   TimeInt scaledBucketStart = scaledTime - scaledOffsetInBucket;
   TimeInt scaledNextBucketStart = scaledBucketStart + duration_.count();
 
   Duration bucketStartMod(
       (scaledBucketStart + buckets_.size() - 1) / buckets_.size());
   Duration nextBucketStartMod(
       (scaledNextBucketStart + buckets_.size() - 1) / buckets_.size());
 
   TimePoint durationStart(numFullDurations * duration_);
   *bucketStart = bucketStartMod + durationStart;
   *nextBucketStart = nextBucketStartMod + durationStart;
 }

template<typename VT , typename CT >

CT::time_point folly::BucketedTimeSeries< VT, CT >::getEarliestTime ( ) const

Definition at line 226 of file BucketedTimeSeries-defs.h.

References folly::BucketedTimeSeries< VT, CT >::empty(), folly::BucketedTimeSeries< VT, CT >::firstTime_, folly::BucketedTimeSeries< VT, CT >::getEarliestTimeNonEmpty(), folly::BucketedTimeSeries< VT, CT >::isAllTime(), and max.

Referenced by folly::BucketedTimeSeries< VT, CT >::elapsed(), and TEST().

                                                                         {
   if (empty()) {
     return TimePoint();
   }
   if (isAllTime()) {
     return firstTime_;
   }
 
   // Compute the earliest time we can track
   TimePoint earliestTime = getEarliestTimeNonEmpty();
 
   // We're never tracking data before firstTime_
   earliestTime = std::max(earliestTime, firstTime_);
 
   return earliestTime;
 }

template<typename VT , typename CT >

CT::time_point folly::BucketedTimeSeries< VT, CT >::getEarliestTimeNonEmpty ( ) const

private

Definition at line 244 of file BucketedTimeSeries-defs.h.

References folly::BucketedTimeSeries< VT, CT >::duration_, folly::BucketedTimeSeries< VT, CT >::getBucketInfo(), and folly::BucketedTimeSeries< VT, CT >::latestTime_.

Referenced by folly::BucketedTimeSeries< VT, CT >::addValueAggregated(), and folly::BucketedTimeSeries< VT, CT >::getEarliestTime().

           {
   size_t currentBucket;
   TimePoint currentBucketStart;
   TimePoint nextBucketStart;
   getBucketInfo(
       latestTime_, &currentBucket, &currentBucketStart, &nextBucketStart);
 
   // Subtract 1 duration from the start of the next bucket to find the
   // earliest possible data point we could be tracking.
   return nextBucketStart - duration_;
 }

template<typename VT, typename CT = LegacyStatsClock<std::chrono::seconds>>

TimePoint folly::BucketedTimeSeries< VT, CT >::getLatestTime ( ) const

inline

Definition at line 151 of file BucketedTimeSeries.h.

Referenced by TEST().

                                   {
     return latestTime_;
   }

template<typename VT, typename CT = LegacyStatsClock<std::chrono::seconds>>

bool folly::BucketedTimeSeries< VT, CT >::isAllTime ( ) const

inline

Definition at line 190 of file BucketedTimeSeries.h.

Referenced by folly::BucketedTimeSeries< VT, CT >::addValueAggregated(), folly::BucketedTimeSeries< VT, CT >::BucketedTimeSeries(), folly::BucketedTimeSeries< VT, CT >::forEachBucket(), folly::BucketedTimeSeries< VT, CT >::getBucketIdx(), folly::BucketedTimeSeries< VT, CT >::getBucketInfo(), folly::BucketedTimeSeries< VT, CT >::getEarliestTime(), and folly::BucketedTimeSeries< VT, CT >::update().

                          {
     return (duration_ == Duration(0));
   }

template<typename VT, typename CT = LegacyStatsClock<std::chrono::seconds>>

TimePoint folly::BucketedTimeSeries< VT, CT >::latestTime ( ) const

inline

Definition at line 219 of file BucketedTimeSeries.h.

Referenced by TEST().

                                {
     return latestTime_;
   }

template<typename VT, typename CT = LegacyStatsClock<std::chrono::seconds>>

size_t folly::BucketedTimeSeries< VT, CT >::numBuckets ( ) const

inline

Definition at line 174 of file BucketedTimeSeries.h.

                             {
     return buckets_.size();
   }

template<typename VT , typename CT >

VT folly::BucketedTimeSeries< VT, CT >::rangeAdjust	(	TimePoint	bucketStart,
		TimePoint	nextBucketStart,
		TimePoint	start,
		TimePoint	end,
		ValueType	input
	)		const

private

Definition at line 479 of file BucketedTimeSeries-defs.h.

References folly::BucketedTimeSeries< VT, CT >::latestTime_, max, and min.

Referenced by folly::BucketedTimeSeries< VT, CT >::avg(), folly::BucketedTimeSeries< VT, CT >::count(), and folly::BucketedTimeSeries< VT, CT >::sum().

                            {
   // If nextBucketStart is greater than latestTime_, treat nextBucketStart as
   // if it were latestTime_.  This makes us more accurate when someone is
   // querying for all of the data up to latestTime_.  Even though latestTime_
   // may only be partially through the bucket, we don't want to adjust
   // downwards in this case, because the bucket really only has data up to
   // latestTime_.
   if (bucketStart <= latestTime_ && nextBucketStart > latestTime_) {
     nextBucketStart = latestTime_ + Duration(1);
   }
 
   if (start <= bucketStart && end >= nextBucketStart) {
     // The bucket is wholly contained in the [start, end) interval
     return input;
   }
 
   TimePoint intervalStart = std::max(start, bucketStart);
   TimePoint intervalEnd = std::min(end, nextBucketStart);
   return input * (intervalEnd - intervalStart) /
       (nextBucketStart - bucketStart);
 }

template<typename VT, typename CT = LegacyStatsClock<std::chrono::seconds>>

template<typename ReturnType = double, typename Interval = Duration>

ReturnType folly::BucketedTimeSeries< VT, CT >::rate ( ) const

inline

Definition at line 308 of file BucketedTimeSeries.h.

Referenced by TEST().

                           {
     return rateHelper<ReturnType, Interval>(ReturnType(total_.sum), elapsed());
   }

template<typename VT, typename CT = LegacyStatsClock<std::chrono::seconds>>

template<typename ReturnType = double, typename Interval = Duration>

ReturnType folly::BucketedTimeSeries< VT, CT >::rate	(	TimePoint	start,
		TimePoint	end
	)		const

inline

Definition at line 371 of file BucketedTimeSeries.h.

References sum().

                                                         {
     ValueType intervalSum = sum(start, end);
     Duration interval = elapsed(start, end);
     return rateHelper<ReturnType, Interval>(intervalSum, interval);
   }

template<typename VT, typename CT = LegacyStatsClock<std::chrono::seconds>>

template<typename ReturnType = double, typename Interval = Duration>

ReturnType folly::BucketedTimeSeries< VT, CT >::rateHelper	(	ReturnType	numerator,
		Duration	elapsedTime
	)		const

inlineprivate

Definition at line 464 of file BucketedTimeSeries.h.

References now().

                                                                           {
     return detail::rateHelper<ReturnType, Duration, Interval>(
         numerator, elapsedTime);
   }

template<typename VT, typename CT = LegacyStatsClock<std::chrono::seconds>>

const ValueType& folly::BucketedTimeSeries< VT, CT >::sum ( ) const

inline

Definition at line 272 of file BucketedTimeSeries.h.

Referenced by folly::MultiLevelTimeSeries< VT, CT >::sum(), TEST(), and testUpdate100x10().

                                {
     return total_.sum;
   }

template<typename VT , typename CT >

VT folly::BucketedTimeSeries< VT, CT >::sum	(	TimePoint	start,
		TimePoint	end
	)		const

Definition at line 281 of file BucketedTimeSeries-defs.h.

References folly::BucketedTimeSeries< VT, CT >::forEachBucket(), folly::BucketedTimeSeries< VT, CT >::rangeAdjust(), and folly::detail::Bucket< T >::sum.

                                                                        {
   ValueType total = ValueType();
   forEachBucket(
       start,
       end,
       [&](const Bucket& bucket,
           TimePoint bucketStart,
           TimePoint nextBucketStart) -> bool {
         total += this->rangeAdjust(
             bucketStart, nextBucketStart, start, end, bucket.sum);
         return true;
       });
 
   return total;
 }

template<typename VT , typename CT >

size_t folly::BucketedTimeSeries< VT, CT >::update ( TimePoint now )

Definition at line 140 of file BucketedTimeSeries-defs.h.

References folly::BucketedTimeSeries< VT, CT >::empty(), folly::BucketedTimeSeries< VT, CT >::firstTime_, folly::BucketedTimeSeries< VT, CT >::getBucketIdx(), folly::BucketedTimeSeries< VT, CT >::isAllTime(), folly::BucketedTimeSeries< VT, CT >::latestTime_, max, now(), and folly::BucketedTimeSeries< VT, CT >::updateBuckets().

Referenced by TEST(), and testUpdate100x10().

                                                        {
   if (empty()) {
     // This is the first data point.
     firstTime_ = now;
   }
 
   // For all-time data, all we need to do is update latestTime_
   if (isAllTime()) {
     latestTime_ = std::max(latestTime_, now);
     return 0;
   }
 
   // Make sure time doesn't go backwards.
   // If the time is less than or equal to the latest time we have already seen,
   // we don't need to do anything.
   if (now <= latestTime_) {
     return getBucketIdx(latestTime_);
   }
 
   return updateBuckets(now);
 }

template<typename VT, typename CT = LegacyStatsClock<std::chrono::seconds>>

size_t folly::BucketedTimeSeries< VT, CT >::update ( Duration now )

inline

Definition at line 458 of file BucketedTimeSeries.h.

                               {
     return update(TimePoint(now));
   }

template<typename VT , typename CT >

size_t folly::BucketedTimeSeries< VT, CT >::updateBuckets ( TimePoint now )

private

Definition at line 163 of file BucketedTimeSeries-defs.h.

References folly::BucketedTimeSeries< VT, CT >::buckets_, folly::detail::Bucket< T >::clear(), folly::BucketedTimeSeries< VT, CT >::duration_, folly::BucketedTimeSeries< VT, CT >::getBucketIdx(), folly::BucketedTimeSeries< VT, CT >::getBucketInfo(), folly::BucketedTimeSeries< VT, CT >::latestTime_, now(), and folly::BucketedTimeSeries< VT, CT >::total_.

Referenced by folly::BucketedTimeSeries< VT, CT >::addValueAggregated(), and folly::BucketedTimeSeries< VT, CT >::update().

                                                               {
   // We could cache nextBucketStart as a member variable, so we don't have to
   // recompute it each time update() is called with a new timestamp value.
   // This makes things faster when update() (or addValue()) is called once
   // per second, but slightly slower when update() is called multiple times a
   // second.  We care more about optimizing the cases where addValue() is being
   // called frequently.  If addValue() is only being called once every few
   // seconds, it doesn't matter as much if it is fast.
 
   // Get info about the bucket that latestTime_ points at
   size_t currentBucket;
   TimePoint currentBucketStart;
   TimePoint nextBucketStart;
   getBucketInfo(
       latestTime_, &currentBucket, &currentBucketStart, &nextBucketStart);
 
   // Update latestTime_
   latestTime_ = now;
 
   if (now < nextBucketStart) {
     // We're still in the same bucket.
     // We're done after updating latestTime_.
     return currentBucket;
   } else if (now >= currentBucketStart + duration_) {
     // It's been a while.  We have wrapped, and all of the buckets need to be
     // cleared.
     for (Bucket& bucket : buckets_) {
       bucket.clear();
     }
     total_.clear();
     return getBucketIdx(latestTime_);
   } else {
     // clear all the buckets between the last time and current time, meaning
     // buckets in the range [(currentBucket+1), newBucket]. Note that
     // the bucket (currentBucket+1) is always the oldest bucket we have. Since
     // our array is circular, loop when we reach the end.
     size_t newBucket = getBucketIdx(now);
     size_t idx = currentBucket;
     while (idx != newBucket) {
       ++idx;
       if (idx >= buckets_.size()) {
         idx = 0;
       }
       total_ -= buckets_[idx];
       buckets_[idx].clear();
     }
     return newBucket;
   }
 }