EXPECT_TRUE(
      profiler->ShouldCompileCluster(function, DeviceCompileMode::kAsync, 0));

  // Should not allow compilation since this is not the first execution and
  // we've already reached the maximum number of ongoing compilations allowed.
  profiler->RegisterExecution(function);
  EXPECT_FALSE(
      profiler->ShouldCompileCluster(function, DeviceCompileMode::kAsync, 0));

  profiler->DecrementOngoingAsyncCompilations();

  std::optional<int64_t> compile_threshold;
  if (compile_mode == DeviceCompileMode::kLazy) {
    compile_threshold = kDefaultCompilationThreshold;
  } else if (compile_mode == DeviceCompileMode::kAsync) {
    compile_threshold = 0;  // for now, always compile right away.
  }

  if (compile_mode == DeviceCompileMode::kStrict) {
    // Lazy compilation is disabled.
    return true;
  }

namespace tensorflow {
// The number of compiler threads to use for asynchronous device compilation.
inline constexpr int64_t kNumAsyncDeviceCompilerThreads = 10;

enum class DeviceCompileMode {
  kLazy,
  kStrict,
  kAsync,
};

enum class DeviceCompileState {
  kUncompiled,
  kCompiling,
  kCompiled,
};

// Creates a single-node graph using the specified `node_def` as the only op

  EXPECT_FALSE(status.ok());
  EXPECT_TRUE(absl::StrContains(status.message(), "XLA compilation disabled"));

  // Check that async compilation is disallowed.
  status = xla_device_compiler->CompileIfNeeded(
      XlaCompiler::Options{}, fn, args, XlaCompiler::CompileOptions{},
      DeviceCompileMode::kAsync, profiler, &compilation_result, &executable);
  EXPECT_FALSE(status.ok());

  NameAttrList fn;
  fn.set_name("foo");

  // Using a mock here to determine when the async compilation finishes. This is
  // to avoid using absl::SleepFor().
  // `RegisterCompilation` is the last call that happens just before the async
  // compilation completes. We use the completion of this call to determine when
  // the compilation finshes to verify expected behavior.

  // Explicitly capture all required data by value for async compilation.
  // Update compilation state in cache.
  cache_->Store(signature, DeviceCompileState::kCompiling, std::nullopt,
                std::nullopt, std::nullopt);
  profiler->IncrementOngoingAsyncCompilations();
  // Don't move the above code into the thread function as it synchronously
  // updates the async compilation state!

  }
  DeviceCompileMode compile_mode = [&] {
    if (must_compile_) {
      return DeviceCompileMode::kStrict;
    }
    return GetXlaOpsCommonFlags()->tf_xla_async_compilation
               ? DeviceCompileMode::kAsync
               : DeviceCompileMode::kLazy;
  }();

  bool use_pjrt =
      GetXlaOpsCommonFlags()
          ->tf_xla_use_device_api.IsEnabledInXlaCompileAndRunForDevice(

// Copyright 2017 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package mysync

import "runtime"

type WaitGroup struct {
	Callers []uintptr
}

func (wg *WaitGroup) Add(x int) {
	wg.Callers = make([]uintptr, 32)
	n := runtime.Callers(1, wg.Callers)
	wg.Callers = wg.Callers[:n]
}

func (wg *WaitGroup) Done() {
	wg.Add(-1)

```Python hl_lines="2-3"
@app.get('/burgers')
async def read_burgers():
    burgers = await get_burgers(2)
    return burgers
```

### More technical details

You might have noticed that `await` can only be used inside of functions defined with `async def`.

```Python hl_lines="2 3"
@app.get('/burgers')
async def read_burgers():
    burgers = await get_burgers(2)
    return burgers
```

### Mais detalhes técnicos

Você deve ter observado que `await` pode ser usado somente dentro de funções definidas com `async def`.