bs, ok := r.Cache[bucket]
	if !ok {
		bs = newBucketReplicationStats()
		r.Cache[bucket] = bs
	}
	b, ok := bs.Stats[ri.Arn]
	if !ok {
		b = &BucketReplicationStat{
			XferRateLrg: newXferStats(),
			XferRateSml: newXferStats(),
		}
		bs.Stats[ri.Arn] = b
	}

	switch {
	case rs.Completed:
		b.ReplicatedSize += rs.TransferSize
		b.ReplicatedCount++
		if rs.TransferDuration > 0 {

}

func (sr *SRStats) update(st replStat, dID string) {
	sr.lock.Lock()
	defer sr.lock.Unlock()
	srs, ok := sr.M[dID]
	if !ok {
		srs = &SRStatus{
			XferRateLrg: newXferStats(),
			XferRateSml: newXferStats(),
		}
	}
	srs.Endpoint = st.Endpoint
	srs.Secure = st.Secure
	switch {
	case st.Completed:
		srs.ReplicatedSize += st.TransferSize
		srs.ReplicatedCount++

	qs.ActiveWorkers = globalReplicationStats.ActiveWorkers()
	qs.XferStats = make(map[RMetricName]XferStats)
	qs.QStats = r.qCache.getSiteStats()

	r.RLock()
	defer r.RUnlock()
	tx := newXferStats()
	for _, brs := range r.Cache {
		for _, v := range brs.Stats {
			tx := tx.merge(*v.XferRateLrg)
			tx = tx.merge(*v.XferRateSml)
		}
	}
	qs.XferStats[Total] = *tx
	return qs
}

	peak := rx.Peak
	if curr > peak {
		peak = curr
	}
	return &XferStats{
		Curr:    curr,
		Avg:     rx.Avg,
		Peak:    peak,
		N:       rx.N,
		measure: rx.measure,
	}
}

func newXferStats() *XferStats {
	return &XferStats{
		measure: newRateMeasurement(time.Now()),
		sma:     newSMA(50),
	}
}

func (rx *XferStats) String() string {