GoStart(2, x, y, 0, x / 2, y / 2, y, a, n);
	GoStart(3, x, y, x / 2, x, y / 2, y, a, n);
	GoWait(0);
	GoWait(1);
	GoWait(2);
	GoWait(3);
}

// The actual computation.  This is called in parallel.
void
DoStep(int xdim, int ydim, int xstart, int xend, int ystart, int yend, int *a, int *n)
{
	int x, y, c, i, j;

	for(x = xstart; x < xend; x++) {
		for(y = ystart; y < yend; y++) {

import org.apache.maven.api.annotations.Nullable;

/**
 * Interface used to locate the root directory for a given project.
 *
 * The root locator is usually looked up from the plexus container.
 * One notable exception is the computation of the early {@code session.rootDirectory}
 * property which happens very early.  The implementation used in this case
 * will be discovered using the JDK service mechanism.
 *

import org.apache.maven.api.annotations.Nullable;

/**
 * Interface used to locate the root directory for a given project.
 *
 * The root locator is usually looked up from the plexus container.
 * One notable exception is the computation of the early {@code session.rootDirectory}
 * property which happens very early.  The implementation used in this case
 * will be discovered using the JDK service mechanism.
 *

		go func() {
			once.Do(onceBody)
			done <- true
		}()
	}
	for i := 0; i < 10; i++ {
		<-done
	}
	// Output:
	// Only once
}

// This example uses OnceValue to perform an "expensive" computation just once,
// even when used concurrently.
func ExampleOnceValue() {
	once := sync.OnceValue(func() int {
		sum := 0
		for i := 0; i < 1000; i++ {
			sum += i
		}
		fmt.Println("Computed once:", sum)

 * contextual module to provide declarations differently, such as providing alternative declarations for an outsider module. Some
 * functionality such as package set computation may also depend on the contextual module, as the declaration provider may require
 * additional information not available in the [scope].
 */

      }
    } else if (src_outside_compilation && !dst_outside_compilation) {
      // Case 1b: outside compilation to its XLA computation control edge.
      ReplaceAttr(e->src(), kXlaConnectedToXlaComputationAttrName, true);
    } else if (!src_outside_compilation && dst_outside_compilation) {
      // Case 1b: XLA computation to outside compilation in it control edge.
      ReplaceAttr(e->dst(), kXlaConnectedFromXlaComputationAttrName, true);
    }

// OpKernelContext in the above function.
// - `device`: the device used to compile the function.
// - `rm`: the resource manager for DeviceCompiler to store JIT-compiled XLA
// computation.
// - `flr`: the FunctionLibraryRuntime for the `function`.
Status CompileToPjRtLoadedExecutable(
    const DeviceBase* device, const XlaPlatformInfo& platform_info,
    const NameAttrList& function,

// point constant.
def : Pat<(TFL_DequantizeOp
             (TFL_QuantizeOp (Arith_ConstantOp F32ElementsAttr:$cst), $qt)),
          (TFL_ConstOp $cst)>;

// Transpose conv supports hybrid computation with quantized weights.
def FoldQuantWeightsIntoTposeConv : Pat<
  (TFL_TransposeConvOp
    $output_shape,
    (TFL_DequantizeOp $quant_weights),
    $quant_input,
    $bias, $padding, $stride_h, $stride_w, $faf),

// The concepts and code are heavily influenced by https://cs.opensource.google/go/go/+/go1.19:src/sync/once.go.
package lazy

import (
	"sync"
	"sync/atomic"
)

// Lazy represents a value whose computation is deferred until the first access
type Lazy[T any] interface {
	// Get returns the value, computing it if necessary.
	Get() (T, error)
}

type lazyImpl[T any] struct {
	getter func() (T, error)

  // A non-blocking version of `Execute`. After each call, `Join` must be called
  // before `StartExecute` is called again. Using `StartExecute` with `Join`
  // allows the caller to schedule computation on multiple ParallelDevices
  // without sequencing those operations (first call `StartExecute` on each
  // parallel device, then call `Join` on each; even if some of the `Join`s