protected Set<ProjectInternal> getLockedProjects() {
        return locks.findAll { it.locked }.collect { it.project } as Set
    }

    protected void recordLocks(Closure cl) {
        acquired.clear()
        cl()
        acquired.clear()
    }

    protected ProjectInternal project(ProjectInternal parent = null, String name = "root") {

            WorkSource.Selection selection
            assert !finalizedPlan.allExecutionComplete()
            assert finalizedPlan.executionState() == WorkSource.State.MaybeWorkReadyToStart
            recordLocks {
                selection = finalizedPlan.selectNext()
            }
            assert !selection.noMoreWorkToStart && !selection.noWorkReadyToStart
            assert !finalizedPlan.allExecutionComplete()

func (f baseMetric) Increment() {
	f.rest.Record(1)
}

func (f baseMetric) Decrement() {
	f.rest.Record(-1)
}

func (f baseMetric) runRecordHook(value float64) {
	recordHookMutex.RLock()
	if rh, ok := recordHooks[f.name]; ok {
		lv := slices.Map(f.attrs, func(e attribute.KeyValue) LabelValue {
			return LabelValue{e}
		})
		rh.OnRecord(f.name, lv, value)
	}
	recordHookMutex.RUnlock()
}

	OnRecord(name string, tags []LabelValue, value float64)
}

var (
	recordHooks     = map[string]RecordHook{}
	recordHookMutex sync.RWMutex
)

// RegisterRecordHook adds a RecordHook for a given measure.
func RegisterRecordHook(name string, h RecordHook) {
	recordHookMutex.Lock()
	defer recordHookMutex.Unlock()
	recordHooks[name] = h
}

// NewSum creates a new Sum Metric (the values will be cumulative).

	if lt.timeStart != 0 {
		nowTime := nanotime()
		gp.m.mLockProfile.waitTime.Add((nowTime - lt.timeStart) * lt.timeRate)
	}

	if lt.tickStart != 0 {
		nowTick := cputicks()
		gp.m.mLockProfile.recordLock(nowTick-lt.tickStart, lt.lock)
	}
}

type mLockProfile struct {
	waitTime   atomic.Int64 // total nanoseconds spent waiting in runtime.lockWithRank