// Stop completes a monitoring region.
func (mm *MemoryMonitor) Stop(ctx context.Context) {
// NB: No need to lock mm.mu here, when StopMonitor() is called the
// monitor is not shared any more.
if log.V(1) {
log.InfofDepth(ctx, 1, "%s, memory usage max %s",
mm.name,
humanizeutil.IBytes(mm.mu.maxAllocated))
}
if mm.mu.curAllocated != 0 {
panic(fmt.Sprintf("%s: unexpected leftover memory: %d bytes",
mm.name,
mm.mu.curAllocated))
}
mm.releaseBudget(ctx)
if mm.maxBytesHist != nil && mm.mu.maxAllocated > 0 {
// TODO(knz) We record the logarithm because the UI doesn't know
// how to do logarithmic y-axes yet. See the explanatory comments
// in sql/mem_metrics.go.
val := int64(1000 * math.Log(float64(mm.mu.maxAllocated)) / math.Ln10)
mm.maxBytesHist.RecordValue(val)
}
// Disable the pool for further allocations, so that further
// uses outside of monitor control get errors.
mm.pool = nil
// Release the reserved budget to its original pool, if any.
mm.reserved.Close()
}
// insertCPutFn is used by insertRow when conflicts should be respected.
// logValue is used for pretty printing.
func insertCPutFn(ctx context.Context, b puter, key *roachpb.Key, value *roachpb.Value) {
// TODO(dan): We want do this V(2) log everywhere in sql. Consider making a
// client.Batch wrapper instead of inlining it everywhere.
if log.V(2) {
log.InfofDepth(ctx, 1, "CPut %s -> %s", *key, value.PrettyPrint())
}
b.CPut(key, value, nil)
}
// MakeUnlimitedMonitor creates a new monitor and starts the monitor
// in "detached" mode without a pool and without a maximum budget.
func MakeUnlimitedMonitor(
ctx context.Context,
name string,
curCount *metric.Counter,
maxHist *metric.Histogram,
noteworthy int64,
) MemoryMonitor {
if log.V(2) {
log.InfofDepth(ctx, 1, "%s: starting unlimited monitor", name)
}
return MemoryMonitor{
name: name,
noteworthyUsageBytes: noteworthy,
curBytesCount: curCount,
maxBytesHist: maxHist,
poolAllocationSize: DefaultPoolAllocationSize,
reserved: MakeStandaloneBudget(math.MaxInt64),
}
}
// Start begins a monitoring region.
// Arguments:
// - pool is the upstream memory monitor that provision allocations
// exceeding the pre-reserved budget. If pool is nil, no upstream
// allocations are possible and the pre-reserved budget determines the
// entire capacity of this monitor.
//
// - reserved is the pre-reserved budget (see above).
func (mm *MemoryMonitor) Start(ctx context.Context, pool *MemoryMonitor, reserved BoundAccount) {
if mm.mu.curAllocated != 0 {
panic(fmt.Sprintf("%s: started with %d bytes left over", mm.name, mm.mu.curAllocated))
}
if mm.pool != nil {
panic(fmt.Sprintf("%s: already started with pool %s", mm.name, mm.pool.name))
}
mm.pool = pool
mm.mu.curAllocated = 0
mm.mu.maxAllocated = 0
mm.mu.curBudget.curAllocated = 0
mm.reserved = reserved
if log.V(2) {
poolname := "(none)"
if pool != nil {
poolname = pool.name
}
log.InfofDepth(ctx, 1, "%s: starting monitor, reserved %s, pool %s",
mm.name,
humanizeutil.IBytes(mm.reserved.curAllocated),
poolname)
}
}
func (*logger) Println(args ...interface{}) {
log.InfofDepth(context.TODO(), 2, "", args...)
}
func (*logger) Printf(format string, args ...interface{}) {
log.InfofDepth(context.TODO(), 2, format, args...)
}
func (r *raftLogger) Infof(format string, v ...interface{}) {
if log.V(2) {
log.InfofDepth(r.ctx, 1, format, v...)
}
}
func (r *raftLogger) Info(v ...interface{}) {
if log.V(2) {
log.InfofDepth(r.ctx, 1, "", v...)
}
}
// insertPutFn is used by insertRow when conflicts should be ignored.
// logValue is used for pretty printing.
func insertPutFn(ctx context.Context, b puter, key *roachpb.Key, value *roachpb.Value) {
if log.V(2) {
log.InfofDepth(ctx, 1, "Put %s -> %s", *key, value.PrettyPrint())
}
b.Put(key, value)
}