비동기 Scope Guard 기반 결정적 Cleanup 호출과 자원 해제

RenderSlotBroker:
- acquireAsync()
- releaseAsync(token)

RenderSlotToken:
- slotId
- leaseId

1. 렌더링 슬롯 획득
2. 렌더링 실행
3. 슬롯 반환

- 정상 완료
- 입력 파일 해석 실패
- GPU 작업 실패
- 호출자 취소
- 메서드 중간 return

await broker.releaseAsync(token)

await using / async with
→ 블록 안에서는 slotId 사용
→ 블록을 벗어나면 자동으로 releaseAsync 실행

RenderSlotBroker
- acquire가 정상 반환하기 전에 응답 형식과 token을 검증
- 외부 응답을 언어 내부의 immutable/plain token 값으로 복사
- 정상 반환 시 token 소유권을 호출자에게 이전
- timeout처럼 결과가 불명확한 획득은 request id와 lease TTL로 회수

RenderSlotLease
- acquire: 비동기
- getSlotId: 활성 상태에서만 사용
- dispose/exit: 비동기
- 완료 뒤의 순차 중복 해제: no-op
- 동시 dispose caller: 이 예제의 지원 범위 밖
- 해제 시작 후 재사용: 금지

class RenderSlotLease {
public:
    ~RenderSlotLease() {
        co_await broker_.release(token_); // 오류: 소멸자는 coroutine이 될 수 없다.
    }
};

#include <boost/asio.hpp>

#include <exception>
#include <optional>
#include <stdexcept>
#include <string>
#include <utility>

namespace asio = boost::asio;

struct RenderSlotToken {
    std::string slot_id;
    std::string lease_id;
};

struct RenderJob {
    std::string job_id;
    std::string input_key;
};

struct RenderReceipt {
    std::string job_id;
    std::string output_key;
};

class RenderSlotBroker {
public:
    virtual asio::awaitable<RenderSlotToken> acquire() = 0;

    // 호출자 취소와 분리된 짧은 timeout, 멱등 release를 내부에서 적용한다.
    virtual asio::awaitable<void> release_for_cleanup(
        RenderSlotToken token) = 0;

    virtual ~RenderSlotBroker() = default;
};

class Renderer {
public:
    virtual asio::awaitable<RenderReceipt> render(
        RenderJob job,
        std::string slot_id) = 0;

    virtual ~Renderer() = default;
};

class RenderAndCleanupFailed final : public std::runtime_error {
public:
    RenderAndCleanupFailed(
        std::exception_ptr body_error,
        std::exception_ptr cleanup_error)
        : std::runtime_error("render and slot cleanup both failed"),
          body_error_(std::move(body_error)),
          cleanup_error_(std::move(cleanup_error)) {}

    const std::exception_ptr& body_error() const noexcept {
        return body_error_;
    }

    const std::exception_ptr& cleanup_error() const noexcept {
        return cleanup_error_;
    }

private:
    std::exception_ptr body_error_;
    std::exception_ptr cleanup_error_;
};

asio::awaitable<RenderReceipt> execute_render_job(
    RenderJob job,
    RenderSlotBroker& broker,
    Renderer& renderer)
{
    // 정상 반환한 token은 broker가 이미 검증했다.
    RenderSlotToken token = co_await broker.acquire();

    std::optional<RenderReceipt> receipt;
    std::exception_ptr body_error;

    try {
        receipt.emplace(
            co_await renderer.render(
                std::move(job),
                token.slot_id));
    } catch (...) {
        // cleanup 뒤에 원래 오류를 다시 던지기 위해 보관한다.
        body_error = std::current_exception();
    }

    std::exception_ptr cleanup_error;
    bool was_cancelled = false;

    try {
        // Asio는 취소된 coroutine의 다음 co_await에서 예외를 던질 수 있다.
        // cleanup 동안만 자동 throw를 끈다. 이 설정만으로 하위 operation에
        // 전달된 cancellation이 제거되는 것은 아니므로, 아래 broker 계약이
        // 별도 timeout/취소 경계를 제공해야 한다.
        // 이 helper는 진입 시 throw_if_cancelled(true)였다는 일반 정책을 전제한다.
        co_await asio::this_coro::throw_if_cancelled(false);

        co_await broker.release_for_cleanup(std::move(token));
    } catch (...) {
        cleanup_error = std::current_exception();
    }

    // throw_if_cancelled(true)는 이미 발생한 cancellation을 다시 던져 주지
    // 않는다. 따라서 cleanup 뒤 cancellation 상태를 관찰하고, 필요하면
    // 아래에서 명시적으로 취소 결과를 만든다.
    try {
        auto cancellation_state =
            co_await asio::this_coro::cancellation_state;
        was_cancelled = cancellation_state.cancelled()
            != asio::cancellation_type::none;
    } catch (...) {
        if (!cleanup_error) {
            cleanup_error = std::current_exception();
        }
        // 이미 release 실패가 있으면 그 오류를 보존한다.
    }

    if (body_error && cleanup_error) {
        throw RenderAndCleanupFailed(
            std::move(body_error),
            std::move(cleanup_error));
    }

    if (cleanup_error) {
        std::rethrow_exception(cleanup_error);
    }

    if (body_error) {
        std::rethrow_exception(body_error);
    }

    if (was_cancelled) {
        throw asio::system_error(asio::error::operation_aborted);
    }

    co_return std::move(receipt).value();
}

using System;
using System.Threading;
using System.Threading.Tasks;

public readonly record struct RenderSlotToken(
    string SlotId,
    string LeaseId);

public interface IRenderSlotBroker
{
    ValueTask<RenderSlotToken> AcquireAsync(
        CancellationToken cancellationToken);

    ValueTask ReleaseAsync(
        RenderSlotToken token);
}

public sealed class RenderSlotLease : IAsyncDisposable
{
    private readonly RenderSlotToken token;

    private IRenderSlotBroker? broker;
    private int disposeStarted;

    private RenderSlotLease(
        IRenderSlotBroker broker,
        RenderSlotToken token)
    {
        this.broker = broker;
        this.token = token;
    }

    public static async Task<RenderSlotLease> AcquireAsync(
        IRenderSlotBroker broker,
        CancellationToken cancellationToken = default)
    {
        ArgumentNullException.ThrowIfNull(broker);

        RenderSlotToken token =
            await broker.AcquireAsync(cancellationToken)
                .ConfigureAwait(false);

        // Broker가 정상 반환한 token은 이미 검증되었고,
        // 호출자가 반환 책임을 넘겨받을 수 있다는 계약이다.
        return new RenderSlotLease(broker, token);
    }

    public string GetSlotId()
    {
        this.EnsureActive();
        return this.token.SlotId;
    }

    public async ValueTask DisposeAsync()
    {
        if (Interlocked.Exchange(ref this.disposeStarted, 1) != 0)
        {
            return;
        }

        IRenderSlotBroker? owner = this.broker;
        this.broker = null;

        if (owner is null)
        {
            return;
        }

        await owner.ReleaseAsync(this.token)
            .ConfigureAwait(false);
    }

    private void EnsureActive()
    {
        if (Volatile.Read(ref this.disposeStarted) != 0)
        {
            throw new ObjectDisposedException(
                nameof(RenderSlotLease));
        }
    }

}

await using RenderSlotLease lease =
    await RenderSlotLease.AcquireAsync(
        broker,
        cancellationToken);

string slotId = lease.GetSlotId();

export type RenderSlotToken = Readonly<{
  slotId: string;
  leaseId: string;
}>;

export type RenderSlotBroker = Readonly<{
  acquireAsync: (
    signal?: AbortSignal,
  ) => Promise<RenderSlotToken>;

  releaseAsync: (
    token: RenderSlotToken,
  ) => Promise<void>;
}>;

export class RenderSlotLease implements AsyncDisposable
{
  readonly #token: RenderSlotToken;

  #broker: RenderSlotBroker | undefined;
  #disposeStarted = false;

  private constructor(
    broker: RenderSlotBroker,
    token: RenderSlotToken,
  )
  {
    this.#broker = broker;
    this.#token = token;
  }

  public static async acquireAsync(
    broker: RenderSlotBroker,
    signal?: AbortSignal,
  ): Promise<RenderSlotLease>
  {
    signal?.throwIfAborted();

    const token = await broker.acquireAsync(signal);

    // broker가 정상 반환한 token은 이미 검증됐다는 계약이다.
    return new RenderSlotLease(
      broker,
      token,
    );
  }

  public getSlotId(): string
  {
    this.#ensureActive();
    return this.#token.slotId;
  }

  public async [Symbol.asyncDispose](): Promise<void>
  {
    if (this.#disposeStarted) {
      return;
    }

    this.#disposeStarted = true;

    const broker = this.#broker;
    this.#broker = undefined;

    if (broker === undefined) {
      return;
    }

    await broker.releaseAsync(this.#token);
  }

  #ensureActive(): void
  {
    if (this.#disposeStarted) {
      throw new Error(
        "이미 해제된 RenderSlotLease입니다.",
      );
    }
  }
}

await using lease =
  await RenderSlotLease.acquireAsync(
    broker,
    signal,
  );

const slotId = lease.getSlotId();

from __future__ import annotations

from collections.abc import AsyncIterator
from contextlib import (
    AbstractAsyncContextManager,
    asynccontextmanager,
)
from dataclasses import dataclass
from types import TracebackType
from typing import Protocol, Self


@dataclass(frozen=True, slots=True)
class RenderSlotToken:
    slot_id: str
    lease_id: str


class RenderSlotBroker(Protocol):
    async def acquire(
        self,
    ) -> RenderSlotToken:
        ...

    async def release(
        self,
        token: RenderSlotToken,
    ) -> None:
        ...


class RenderSlotLease(
    AbstractAsyncContextManager["RenderSlotLease"]
):
    def __init__(
        self,
        broker: RenderSlotBroker,
        token: RenderSlotToken,
    ) -> None:
        self._broker: RenderSlotBroker | None = broker
        self._token = token
        self._dispose_started = False

    @classmethod
    async def acquire(
        cls,
        broker: RenderSlotBroker,
    ) -> Self:
        token = await broker.acquire()
        # broker가 정상 반환한 token은 이미 검증됐다는 계약이다.
        return cls(broker, token)

    async def __aenter__(
        self,
    ) -> Self:
        self._ensure_active()
        return self

    async def __aexit__(
        self,
        exception_type: type[BaseException] | None,
        exception: BaseException | None,
        traceback: TracebackType | None,
    ) -> bool:
        del exception_type
        del exception
        del traceback

        await self.aclose()
        return False

    async def aclose(self) -> None:
        if self._dispose_started:
            return

        self._dispose_started = True

        broker = self._broker
        self._broker = None

        if broker is None:
            return

        await broker.release(self._token)

    def get_slot_id(self) -> str:
        self._ensure_active()
        return self._token.slot_id

    def _ensure_active(self) -> None:
        if self._dispose_started:
            raise RuntimeError(
                "이미 해제된 RenderSlotLease입니다."
            )


@asynccontextmanager
async def render_slot_scope(
    broker: RenderSlotBroker,
) -> AsyncIterator[RenderSlotLease]:
    # 획득과 cleanup 등록을 하나의 __aenter__ 경계 안에서 끝낸다.
    lease = await RenderSlotLease.acquire(broker)

    try:
        yield lease
    finally:
        await lease.aclose()

async with render_slot_scope(broker) as lease:
    slot_id = lease.get_slot_id()

export type RenderJob = Readonly<{
  jobId: string;
  sourceKey: string;
  outputKey: string;
}>;

export type RenderReceipt = Readonly<{
  jobId: string;
  outputKey: string;
}>;

export type Renderer = Readonly<{
  renderAsync: (
    job: RenderJob,
    slotId: string,
    signal?: AbortSignal,
  ) => Promise<RenderReceipt>;
}>;

export class RenderJobService
{
  readonly #broker: RenderSlotBroker;
  readonly #renderer: Renderer;

  public constructor(
    broker: RenderSlotBroker,
    renderer: Renderer,
  )
  {
    this.#broker = broker;
    this.#renderer = renderer;
  }

  public async executeAsync(
    job: RenderJob,
    signal?: AbortSignal,
  ): Promise<RenderReceipt>
  {
    validateJob(job);

    await using lease =
      await RenderSlotLease.acquireAsync(
        this.#broker,
        signal,
      );

    return await this.#renderer.renderAsync(
      job,
      lease.getSlotId(),
      signal,
    );
  }
}

function validateJob(job: RenderJob): void
{
  if (!isValidIdentifier(job.jobId)) {
    throw new RangeError(
      "jobId 형식이 유효하지 않습니다.",
    );
  }

  if (job.sourceKey.length === 0
    || job.outputKey.length === 0) {
    throw new RangeError(
      "입력과 출력 key는 비어 있을 수 없습니다.",
    );
  }
}

function isValidIdentifier(value: string): boolean
{
  return /^[A-Za-z0-9_.:-]{1,128}$/.test(value);
}

API Boundary
= RenderJob 입력 검증

RenderJobService
= lease 획득
→ renderer 호출
→ scope 종료

RenderSlotLease
= 슬롯의 process-local 소유권 표현
= broker cleanup entry point를 중복 시작하지 않음

RenderSlotBroker
= 원격 coordinator I/O
= release timeout과 protocol 처리

Renderer
= 실제 GPU 작업 수행
= 슬롯 반환 책임 없음

Central Policy Handler
= 획득 실패
= 렌더링 실패
= 슬롯 해제 실패
= 취소와 timeout 분류
= 언어별 규칙에 따라 본문 오류와 cleanup 오류를 함께 보존

coordinator가 슬롯 할당 완료
→ 응답이 네트워크에서 유실
→ client의 acquire는 timeout
→ lease 객체는 만들어지지 않음

자원을 누가 획득하는가
-> 획득 성공 시점이 명확한가
-> 자원의 소유자가 한 객체로 고정되는가
-> 사용 범위가 lexical block으로 제한되는가
-> 정상 종료·return·예외에서 모두 해제되는가
-> 해제가 비동기라면 완료를 await하는가
-> 중복 해제가 no-op인가
-> 해제 시작 후 자원 접근을 차단하는가
-> 호출자 취소가 cleanup까지 무효화하지 않는가
-> cleanup 실패가 중앙 정책 계층까지 전파되는가

- 비동기 DB connection과 transaction
- 원격 작업 슬롯
- 분산 semaphore permit
- 임시 object-storage upload session
- 비동기 message consumer
- flush가 필요한 buffered writer

DB transaction
  성공 경로 -> 명시적 CommitAsync
  예외·미완료 scope 종료 -> RollbackAsync 또는 dispose

multipart upload
  성공 경로 -> CompleteAsync
  예외·미완료 scope 종료 -> AbortAsync

생성자에서 broker를 주입받음
→ broker의 수명은 외부 composition root 소유
→ lease가 broker 자체를 dispose하면 안 됨

broker에서 token을 획득함
→ token의 반환 책임은 lease 소유
→ scope 종료 시 release해야 함

첫 Dispose
-> 소유권 제거
-> 원격 release

두 번째 Dispose
-> 이미 소유권 없음
-> no-op

렌더링 성공
→ 슬롯 반환 실패

렌더링 실패
→ 슬롯 반환도 실패

public readonly record struct Unit;

public interface IResultRenderSlotBroker
{
    ValueTask<Result<RenderSlotToken>> AcquireAsync(
        CancellationToken cancellationToken);

    ValueTask<Result<Unit>> ReleaseAsync(
        RenderSlotToken token,
        CancellationToken cancellationToken);
}

public static class LeaseExecution
{
    public static async ValueTask<Result<T>> ExecuteWithLeaseAsync<T>(
        IResultRenderSlotBroker broker,
        Func<string, CancellationToken, ValueTask<Result<T>>> body,
        TimeSpan cleanupTimeout,
        CancellationToken callerToken = default)
    {
        ArgumentNullException.ThrowIfNull(broker);
        ArgumentNullException.ThrowIfNull(body);

        if (cleanupTimeout <= TimeSpan.Zero)
        {
            throw new ArgumentOutOfRangeException(
                nameof(cleanupTimeout),
                "Cleanup timeout must be positive.");
        }

        Result<RenderSlotToken> acquired;

        try
        {
            acquired = await broker.AcquireAsync(callerToken)
                .ConfigureAwait(false);
        }
        catch (OperationCanceledException ex)
            when (callerToken.IsCancellationRequested)
        {
            return Result<T>.Fail(
                AppError.Cancelled("LEASE_ACQUIRE_CANCELLED", ex));
        }
        catch (Exception ex)
        {
            // Adapter가 미처 값으로 바꾸지 못한 runtime/third-party 예외의 최종 경계다.
            return Result<T>.Fail(
                AppError.Unexpected("LEASE_ACQUIRE_THROWN", ex));
        }

        if (acquired.IsFailure)
        {
            return Result<T>.Fail(acquired.Error);
        }

        RenderSlotToken token = acquired.Value;
        Result<T> bodyResult;

        try
        {
            bodyResult = await body(
                    token.SlotId,
                    callerToken)
                .ConfigureAwait(false);
        }
        catch (OperationCanceledException ex)
            when (callerToken.IsCancellationRequested)
        {
            bodyResult = Result<T>.Fail(
                AppError.Cancelled("LEASE_BODY_CANCELLED", ex));
        }
        catch (Exception ex)
        {
            // 업무 실패는 원래 Result로 와야 한다. 여기서 잡는 것은 예상 밖 예외다.
            bodyResult = Result<T>.Fail(
                AppError.Unexpected("LEASE_BODY_THROWN", ex));
        }

        Result<Unit> cleanupResult;

        using (var cleanupCts =
            new CancellationTokenSource(cleanupTimeout))
        {
            try
            {
                cleanupResult = await broker.ReleaseAsync(
                        token,
                        cleanupCts.Token)
                    .ConfigureAwait(false);
            }
            catch (OperationCanceledException ex)
                when (cleanupCts.IsCancellationRequested)
            {
                cleanupResult = Result<Unit>.Fail(
                    AppError.Timeout("LEASE_CLEANUP_TIMEOUT", ex));
            }
            catch (Exception ex)
            {
                cleanupResult = Result<Unit>.Fail(
                    AppError.Unexpected("LEASE_CLEANUP_THROWN", ex));
            }
        }

        if (bodyResult.IsSuccess && cleanupResult.IsSuccess)
        {
            return bodyResult;
        }

        if (bodyResult.IsFailure && cleanupResult.IsSuccess)
        {
            return bodyResult;
        }

        if (bodyResult.IsSuccess && cleanupResult.IsFailure)
        {
            return Result<T>.Fail(cleanupResult.Error);
        }

        return Result<T>.Fail(
            AppError.Combine(
                "LEASE_BODY_AND_CLEANUP_FAILED",
                bodyResult.Error,
                cleanupResult.Error));
    }
}

- 프로세스 강제 종료
- 장비 전원 차단
- runtime crash
- 네트워크 단절: cleanup 호출은 실행됐지만 원격 적용 결과를 알 수 없는 경우

- 성공 경로에서만 release를 호출함
- cleanup을 await하지 않고 fire-and-forget함
- 호출자 cancellation으로 release까지 즉시 취소함
- dispose 후에도 token을 외부에서 사용할 수 있음
- 중복 dispose가 원격 release를 반복함
- lease가 자신이 소유하지 않은 broker까지 종료함
- cleanup 오류를 로그만 남기고 삼킴
- finalizer나 GC가 적시에 반환할 것으로 기대함
- acquire가 token을 반환한 뒤 factory 검증에서 실패해 guard를 만들지 못함
- remote release에 exactly-once 효과가 있다고 가정함
- lease를 여러 task에 공유한 채 한쪽에서 먼저 dispose함
- Python __aexit__에서 실수로 True를 반환함
- TypeScript runtime의 Symbol.asyncDispose 지원을 확인하지 않음
- C++ 소멸자에서 비동기 cleanup을 기다리려고 event loop를 block함
- C++ 소멸자에서 cleanup coroutine을 detached로 실행하고 완료와 오류를 잃음
- C++ coroutine에 참조 매개변수를 넘겨 임시 객체가 dangling됨
- C++ catch handler 안에서 co_await를 시도해 cleanup 복구가 컴파일되지 않음
- cleanup 상태를 되돌리는 co_await를 오류 수집 구간 밖에 두어 body 오류를 잃음
- Result-First 코드에서 body 실패만 값으로 만들고 cleanup 실패는 예외로 남김
- DisposeAsync가 cleanup 실패를 삼켜 Result 흐름을 지킨 것처럼 보이게 함

async function renderJobBadAsync(
  job: RenderJob,
  broker: RenderSlotBroker,
  renderer: Renderer,
  signal?: AbortSignal,
): Promise<RenderReceipt>
{
  const token = await broker.acquireAsync(signal);

  const receipt = await renderer.renderAsync(
    job,
    token.slotId,
    signal,
  );

  await broker.releaseAsync(token);

  return receipt;
}

acquire 성공
→ render 실패
→ 함수 즉시 종료
→ release 실행되지 않음

- 해제가 성공 경로에만 존재한다.
- return 위치를 추가할 때마다 해제 누락 위험이 생긴다.
- 호출자가 token의 소유권을 직접 관리해야 한다.
- 중복 해제 방어가 없다.
- 해제 후 token 접근을 막을 수 없다.
- 획득과 사용 범위가 타입이나 문법에 드러나지 않는다.

const token = await broker.acquireAsync(signal);

try {
  return await renderer.renderAsync(
    job,
    token.slotId,
    signal,
  );
} finally {
  await broker.releaseAsync(token);
}

- 정상 완료 후 broker.release 호출 1회
- 작업 실패 후에도 broker.release 호출 1회
- dispose를 완료한 뒤 순차 재호출해도 broker.release 호출은 총 1회
- release 실패가 호출자에게 관측됨
- acquire 실패 시 guard가 release를 꾸며 내지 않음
- dispose 시작 뒤 lease 사용이 거절됨

import assert from "node:assert/strict";
import test from "node:test";

class FakeRenderSlotBroker implements RenderSlotBroker
{
  readonly #token: RenderSlotToken = {
    slotId: "slot-1",
    leaseId: "lease-1",
  };

  #acquireCount = 0;
  #releaseCount = 0;

  public constructor(
    readonly failRelease = false,
  ) {}

  public async acquireAsync(): Promise<RenderSlotToken>
  {
    this.#acquireCount += 1;
    return this.#token;
  }

  public async releaseAsync(
    token: RenderSlotToken,
  ): Promise<void>
  {
    assert.deepEqual(token, this.#token);
    this.#releaseCount += 1;

    if (this.failRelease) {
      throw new Error("슬롯 반환 실패");
    }
  }

  public getAcquireCount(): number
  {
    return this.#acquireCount;
  }

  public getReleaseCount(): number
  {
    return this.#releaseCount;
  }
}

test("정상 종료 시 슬롯을 한 번 반환한다", async () =>
{
  const broker = new FakeRenderSlotBroker();

  {
    await using lease =
      await RenderSlotLease.acquireAsync(broker);

    assert.equal(
      lease.getSlotId(),
      "slot-1",
    );
  }

  assert.equal(broker.getAcquireCount(), 1);
  assert.equal(broker.getReleaseCount(), 1);
});

test("본문이 실패해도 슬롯을 반환한다", async () =>
{
  const broker = new FakeRenderSlotBroker();

  await assert.rejects(
    async () =>
    {
      await using lease =
        await RenderSlotLease.acquireAsync(broker);

      assert.equal(
        lease.getSlotId(),
        "slot-1",
      );

      throw new Error("렌더링 실패");
    },
    /렌더링 실패/,
  );

  assert.equal(broker.getReleaseCount(), 1);
});

test("완료 뒤 순차 dispose는 원격 반환을 반복하지 않는다", async () =>
{
  const broker = new FakeRenderSlotBroker();

  const lease =
    await RenderSlotLease.acquireAsync(broker);

  await lease[Symbol.asyncDispose]();
  await lease[Symbol.asyncDispose]();

  assert.equal(broker.getReleaseCount(), 1);
});

test("해제 후 슬롯 접근을 거절한다", async () =>
{
  const broker = new FakeRenderSlotBroker();

  const lease =
    await RenderSlotLease.acquireAsync(broker);

  await lease[Symbol.asyncDispose]();

  assert.throws(
    () =>
    {
      lease.getSlotId();
    },
    /이미 해제된/,
  );
});

test("release 실패를 호출자에게 전파한다", async () =>
{
  const broker = new FakeRenderSlotBroker(true);

  await assert.rejects(
    async () =>
    {
      await using lease =
        await RenderSlotLease.acquireAsync(broker);

      assert.equal(lease.getSlotId(), "slot-1");
    },
    /슬롯 반환 실패/,
  );

  assert.equal(broker.getReleaseCount(), 1);
});

{
  "compilerOptions": {
    "target": "ES2022",
    "lib": [
      "ES2022",
      "ESNext.Disposable"
    ],
    "types": [
      "node"
    ],
    "strict": true,
    "noImplicitReturns": true
  }
}

render_slot.acquire.count
render_slot.acquire.duration_ms
render_slot.release.count
render_slot.release.duration_ms
render_slot.release.failed.count
render_slot.active.count
render_slot.orphan_expired.count

작업 cancellation
= 렌더링을 중단하라는 요청

cleanup timeout
= 획득한 슬롯을 반환하기 위해 허용할 별도 시간

획득한 자원의 소유권을 scope 객체가 보유하고,
scope 종료가 비동기 해제 완료까지 기다린다.

자원을 얻었다면 해제 호출을 기억하지 마라.
해제가 자동으로 따라오는 scope 안에서만 사용하라.