code: func RunMulti(c context.Context, workers int, fn func(MultiRunner) error) error {
  	// Create a Runner to manage our goroutines. We will not set its Maximum,
  	// since we will be metering that internally using our own semaphore.
  	r := Runner{
  		Sustained: workers,
  	}
  	defer r.Close()
  
  	nrc := nestedRunnerContext{
  		ctx:   c,
  		workC: r.WorkC(),
  	}
  	if workers > 0 {
  		// Create a semaphore with (workers-1) tokens. We subtract one because the
  		// runner has an implicit token on virtue of running the work.
  		nrc.sem = make(Semaphore, workers-1)
  	}
  	return fn(&nrc)
  }
docs: // RunMulti initiates a nested RunMulti operation. It invokes an entry function,
  // passing it a MultiRunner instance bound to the supplied constraints. Any
  // nested parallel operations scheduled through that MultiRunner will not
  // starve each other regardless of execution order.
  //
  // This is useful when sharing the same outer Runner constraints with multiple
  // tiers of parallel operations. A naive approach would be to re-use a Runner's
  // WorkC() or Run() functions, but this can result in deadlock if the outer
  // functions consume all available resources running their inner payloads,
  // forcing their inner payloads to block forever.
  //
  // The supplied Context will be monitored for cancellation. If the Context is
  // canceled, new work dispatch will be inhibited. Any methods added to the
  // work channel will not be executed, and RunMulti will treat them as if they
  // ran and immediately returned the Context's Err() value.