}

func (rx *XferStats) merge(o XferStats) XferStats {
	curr := calcAvg(rx.curr(), o.curr(), rx.N, o.N)
	peak := rx.Peak
	if o.Peak > peak {
		peak = o.Peak
	}
	if curr > peak {
		peak = curr
	}
	return XferStats{
		Avg:     calcAvg(rx.Avg, o.Avg, rx.N, o.N),
		Peak:    peak,
		Curr:    curr,
		measure: rx.measure,
		N:       rx.N + o.N,
	}
}

		totpeak = math.Max(math.Max(tot.Peak, totpeak), tot.Curr)
		lpeak = math.Max(math.Max(v[Large].Peak, lpeak), v[Large].Curr)
		speak = math.Max(math.Max(v[Small].Peak, speak), v[Small].Curr)
		if lpeak > 0 || speak > 0 {
			count++
		}
	}
	if count > 0 {
		lrg := XferStats{
			Avg:  lavg / float64(count),
			Curr: lcurr / float64(count),
			Peak: lpeak,
		}
		sml := XferStats{

var bufPool = sync.Pool{
	New: func() any {
		b := make([]byte, 0, 1024)
		return (*Buffer)(&b)
	},
}

func New() *Buffer {
	return bufPool.Get().(*Buffer)
}

func (b *Buffer) Free() {
	// To reduce peak allocation, return only smaller buffers to the pool.
	const maxBufferSize = 16 << 10
	if cap(*b) <= maxBufferSize {
		*b = (*b)[:0]
		bufPool.Put(b)
	}
}

func (b *Buffer) Reset() {
	b.SetLen(0)
}

* Changes to included builds invalidate all cached results, even when the change would not affect the cached results.
* The implementation does not attempt to take advantage of the isolation to limit peak memory consumption. Currently, peak memory consumption is a function of how many project need to be configured.
* All caching is done on the local machine, as for the configuration cache. There is no support for remote caching yet.

== How do I use it?

            return new OsMemoryStatusSnapshot(
                memoryInfo.getTotalPhysicalMemory(), memoryInfo.getAvailablePhysicalMemory(),
                // Note: the commit limit is usually less than the hard limit of the commit peak, but I think it would be prudent
                // for us to not force the user's OS to allocate more page file space, so we'll use the commit limit here.

	if len(qs.XferStats) > 0 {
		tots := qs.XferStats[Total]
		m.Set(replicationAverageDataTransferRate, tots.Avg)
		m.Set(replicationCurrentDataTransferRate, tots.Curr)
		m.Set(replicationMaxDataTransferRate, tots.Peak)
	}

	return nil

}

type latencyStat struct {
	lastmin lastMinuteLatency
	curr    time.Duration
	avg     time.Duration
	peak    time.Duration
	N       int64
}

func (l *latencyStat) update(d time.Duration) {
	l.lastmin.add(d)
	l.N++
	if d > l.peak {
		l.peak = d
	}
	l.curr = l.lastmin.getTotal().avg()
	l.avg = time.Duration((int64(l.avg)*(l.N-1) + int64(l.curr)) / l.N)
}

// Definition is per AMS55 # 4.2.8,
// analytically equivalent to cpow(a,z) = cexp(z clog(a)).
//
// ACCURACY:
//
//                      Relative error:
// arithmetic   domain     # trials      peak         rms
//    IEEE      -10,+10     30000       9.4e-15     1.5e-15

// Pow returns x**y, the base-x exponential of y.
// For generalized compatibility with [math.Pow]:
//
//	Pow(0, ±0) returns 1+0i

			}
		case "av":
			z.Avg, err = dc.ReadFloat64()
			if err != nil {
				err = msgp.WrapError(err, "Avg")
				return
			}
		case "p":
			z.Peak, err = dc.ReadFloat64()
			if err != nil {
				err = msgp.WrapError(err, "Peak")
				return
			}
		case "n":
			z.N, err = dc.ReadInt64()
			if err != nil {
				err = msgp.WrapError(err, "N")
				return
			}
		default:

        final JvmThreadsObj jvmThreadsObj = new JvmThreadsObj();
        jvmObj.threads = jvmThreadsObj;
        jvmThreadsObj.count = threads.getCount();
        jvmThreadsObj.peak = threads.getPeakCount();
        final Classes classes = jvmStats.getClasses();
        final JvmClassesObj jvmClassesObj = new JvmClassesObj();
        jvmObj.classes = jvmClassesObj;