if burstableMin > 0 {
		if configs[v1.PodQOSBurstable].ResourceParameters.Unified == nil {
			configs[v1.PodQOSBurstable].ResourceParameters.Unified = make(map[string]string)
		}
		configs[v1.PodQOSBurstable].ResourceParameters.Unified[Cgroup2MemoryMin] = strconv.FormatInt(burstableMin, 10)
		klog.V(4).InfoS("MemoryQoS config for qos", "qos", v1.PodQOSBurstable, "memoryMin", burstableMin)
	}

	if guaranteedMin > 0 {

	"istio.io/istio/pkg/test/framework/components/echo"
	"istio.io/istio/pkg/test/framework/resource"
)

func Build(ctx resource.Context, configs []echo.Config) (echo.Instances, error) {
	instances := make([]echo.Instance, len(configs))

	g := multierror.Group{}
	for i, cfg := range configs {
		i, cfg := i, cfg
		g.Go(func() (err error) {
			instances[i], err = newInstance(ctx, cfg)
			return
		})
	}

    if (function.getName() == entry_func_id &&
        !configs.export_entry_func_to_flib) {
      entry_func.emplace(function);
    } else {
      TF_RETURN_IF_ERROR(ConvertLibFunction(configs, tf_dialect, symbol_table,
                                            function, &temp_flib_def,
                                            visited_functions));
    }
  }

  if (!configs.export_entry_func_to_flib) {

// This capability is needed for backwards compatibility and will likely be removed.
func replaceKubeconfigs(configs []cluster.Config, kubeconfigs []string) ([]cluster.Config, error) {
	if len(kubeconfigs) == 0 {
		return configs, nil
	}
	kube := 0
	out := []cluster.Config{}
	for _, cfg := range configs {
		if kube >= len(kubeconfigs) {
			// not enough to cover all clusters in file

	// clusters contains the current set of clusters that subsequent With calls will be applied to,
	// if the Config passed to With does not explicitly choose a cluster.
	clusters cluster.Clusters

	// configs contains configurations to be built, expanded per-cluster and grouped by cluster Kind.
	configs []echo.Config
	// refs contains the references to assign built Instances to.

                          const GraphExportConfig& configs,
                          std::unique_ptr<Graph>* graph,
                          FunctionLibraryDefinition* flib_def);

// Converts an MLIR function and adds it to a FunctionLibraryDefinition.
Status ConvertMlirFunctionToFunctionLibraryDef(mlir::func::FuncOp func,
                                               const GraphExportConfig& configs,

                          const GraphExportConfig& configs,
                          std::unique_ptr<Graph>* graph,
                          FunctionLibraryDefinition* flib_def);

// Converts an MLIR function and adds it to a FunctionLibraryDefinition.
Status ConvertMlirFunctionToFunctionLibraryDef(mlir::func::FuncOp func,
                                               const GraphExportConfig& configs,

test:rbe_cross_compile_linux_arm64 --config=rbe_cross_compile_base

# RBE cross-compile configs for XLA Linux Aarch64
build:rbe_cross_compile_linux_arm64_xla --config=cross_compile_linux_arm64_xla
build:rbe_cross_compile_linux_arm64_xla --config=rbe_cross_compile_base_xla
test:rbe_cross_compile_linux_arm64_xla --config=rbe_cross_compile_base_xla

# END LINUX AARCH64 CROSS-COMPILE CONFIGS

	return e.id
}

func (e *Environment) Settings() *Settings {
	return e.s.clone()
}

func buildClusters(configs []cluster.Config) (cluster.Clusters, error) {
	scopes.Framework.Infof("=== BEGIN: Building clusters ===")

	// use multierror to give as much detail as possible if the config is bad
	var errs error
	defer func() {
		if errs != nil {
			scopes.Framework.Infof("=== FAILED: Building clusters ===")
		}

import io.mockk.every
import io.mockk.impl.annotations.MockK
import io.mockk.junit5.MockKExtension
import io.mockk.mockk
import io.mockk.slot
import jetbrains.buildServer.configs.kotlin.BuildStep
import jetbrains.buildServer.configs.kotlin.BuildSteps
import jetbrains.buildServer.configs.kotlin.buildSteps.GradleBuildStep
import model.CIBuildModel
import model.JsonBasedGradleSubprojectProvider
import org.junit.jupiter.api.Assertions.assertEquals