# AcceleratorMemorySize

The minimum amount of memory, in gibibytes (GiB), of each accelerator device exposed to a Lambda Managed Instance (LMI) function's execution environment.

Lambda might allocate more, depending on the accelerator instance types available.

Use one of the predefined values (`AcceleratorMemorySize.GIB_24`, etc.). If the
service adds a size that is not yet listed here, use `AcceleratorMemorySize.of()`
to supply it directly.

Obtainable from: AcceleratorMemorySize.GIB_12, AcceleratorMemorySize.GIB_16, AcceleratorMemorySize.GIB_24, AcceleratorMemorySize.GIB_3, AcceleratorMemorySize.GIB_48, AcceleratorMemorySize.GIB_6, AcceleratorMemorySize.of

- Source: [`aws-lambda/lib/accelerator-config.ts`](https://github.com/aws/aws-cdk/blob/v2.278.0/packages/aws-cdk-lib/aws-lambda/lib/accelerator-config.ts#L14)

## Example

TypeScript:

```ts
import * as ec2 from 'aws-cdk-lib/aws-ec2';

const vpc = new ec2.Vpc(this, 'MyVpc');
const securityGroup = new ec2.SecurityGroup(this, 'SecurityGroup', { vpc });

const gpuCapacityProvider = new lambda.CapacityProvider(this, 'GpuCapacityProvider', {
  subnets: vpc.privateSubnets,
  securityGroups: [securityGroup],
  architectures: [lambda.Architecture.X86_64],
  instanceTypeFilter: lambda.InstanceTypeFilter.allow([
    ec2.InstanceType.of(ec2.InstanceClass.G6, ec2.InstanceSize.XLARGE),
  ]),
  scalingOptions: lambda.ScalingOptions.manual([
    lambda.TargetTrackingScalingPolicy.gpuUtilization(60),
  ]),
});

const fn = new lambda.Function(this, 'MyFunction', {
  runtime: lambda.Runtime.FROM_IMAGE,
  handler: lambda.Handler.FROM_IMAGE,
  code: lambda.Code.fromAssetImage(path.join(__dirname, 'lambda-handler')),
  memorySize: 2048,
  acceleratorConfig: {
    acceleratorMemorySize: lambda.AcceleratorMemorySize.GIB_24,
  },
});

gpuCapacityProvider.addFunction(fn);
```

Python:

```python
import aws_cdk.aws_ec2 as ec2

vpc = ec2.Vpc(self, "MyVpc")
security_group = ec2.SecurityGroup(self, "SecurityGroup", vpc=vpc)

gpu_capacity_provider = lambda_.CapacityProvider(self, "GpuCapacityProvider",
    subnets=vpc.private_subnets,
    security_groups=[security_group],
    architectures=[lambda_.Architecture.X86_64],
    instance_type_filter=lambda_.InstanceTypeFilter.allow([
        ec2.InstanceType.of(ec2.InstanceClass.G6, ec2.InstanceSize.XLARGE)
    ]),
    scaling_options=lambda_.ScalingOptions.manual([
        lambda_.TargetTrackingScalingPolicy.gpu_utilization(60)
    ])
)

fn = lambda_.Function(self, "MyFunction",
    runtime=lambda_.Runtime.FROM_IMAGE,
    handler=lambda_.Handler.FROM_IMAGE,
    code=lambda_.Code.from_asset_image(path.join(__dirname, "lambda-handler")),
    memory_size=2048,
    accelerator_config=lambda.AcceleratorConfig(
        accelerator_memory_size=lambda_.AcceleratorMemorySize.GIB_24
    )
)

gpu_capacity_provider.add_function(fn)
```

Java:

```java
import software.amazon.awscdk.services.ec2.*;

Vpc vpc = new Vpc(this, "MyVpc");
SecurityGroup securityGroup = SecurityGroup.Builder.create(this, "SecurityGroup").vpc(vpc).build();

CapacityProvider gpuCapacityProvider = CapacityProvider.Builder.create(this, "GpuCapacityProvider")
        .subnets(vpc.getPrivateSubnets())
        .securityGroups(List.of(securityGroup))
        .architectures(List.of(Architecture.X86_64))
        .instanceTypeFilter(InstanceTypeFilter.allow(List.of(InstanceType.of(InstanceClass.G6, InstanceSize.XLARGE))))
        .scalingOptions(ScalingOptions.manual(List.of(TargetTrackingScalingPolicy.gpuUtilization(60))))
        .build();

Function fn = Function.Builder.create(this, "MyFunction")
        .runtime(Runtime.FROM_IMAGE)
        .handler(Handler.FROM_IMAGE)
        .code(Code.fromAssetImage(join(__dirname, "lambda-handler")))
        .memorySize(2048)
        .acceleratorConfig(AcceleratorConfig.builder()
                .acceleratorMemorySize(AcceleratorMemorySize.GIB_24)
                .build())
        .build();

gpuCapacityProvider.addFunction(fn);
```

C# / .NET:

```csharp
// Install: dotnet add package Amazon.CDK.Lib
using Amazon.CDK.AWS.EC2;

var vpc = new Vpc(this, "MyVpc");
var securityGroup = new SecurityGroup(this, "SecurityGroup", new SecurityGroupProps { Vpc = vpc });

var gpuCapacityProvider = new CapacityProvider(this, "GpuCapacityProvider", new CapacityProviderProps {
    Subnets = vpc.PrivateSubnets,
    SecurityGroups = new [] { securityGroup },
    Architectures = new [] { Architecture.X86_64 },
    InstanceTypeFilter = InstanceTypeFilter.Allow(new [] { InstanceType.Of(InstanceClass.G6, InstanceSize.XLARGE) }),
    ScalingOptions = ScalingOptions.Manual(new [] { TargetTrackingScalingPolicy.GpuUtilization(60) })
});

var fn = new Function(this, "MyFunction", new FunctionProps {
    Runtime = Runtime.FROM_IMAGE,
    Handler = Handler.FROM_IMAGE,
    Code = Code.FromAssetImage(Join(__dirname, "lambda-handler")),
    MemorySize = 2048,
    AcceleratorConfig = new AcceleratorConfig {
        AcceleratorMemorySize = AcceleratorMemorySize.GIB_24
    }
});

gpuCapacityProvider.AddFunction(fn);
```

Golang:

```go
// Install: go get github.com/aws/aws-cdk-go/awscdk/v2
import "github.com/aws/aws-cdk-go/awscdk"

vpc := ec2.NewVpc(this, jsii.String("MyVpc"))
securityGroup := ec2.NewSecurityGroup(this, jsii.String("SecurityGroup"), &SecurityGroupProps{
	Vpc: Vpc,
})

gpuCapacityProvider := lambda.NewCapacityProvider(this, jsii.String("GpuCapacityProvider"), &CapacityProviderProps{
	Subnets: vpc.PrivateSubnets,
	SecurityGroups: []ISecurityGroup{
		securityGroup,
	},
	Architectures: []Architecture{
		lambda.Architecture_X86_64(),
	},
	InstanceTypeFilter: lambda.InstanceTypeFilter_Allow([]InstanceType{
		ec2.InstanceType_Of(ec2.InstanceClass_G6, ec2.InstanceSize_XLARGE),
	}),
	ScalingOptions: lambda.ScalingOptions_Manual([]TargetTrackingScalingPolicy{
		lambda.TargetTrackingScalingPolicy_GpuUtilization(jsii.Number(60)),
	}),
})

fn := lambda.NewFunction(this, jsii.String("MyFunction"), &FunctionProps{
	Runtime: lambda.Runtime_FROM_IMAGE(),
	Handler: lambda.Handler_FROM_IMAGE(),
	Code: lambda.Code_FromAssetImage(path.join(__dirname, jsii.String("lambda-handler"))),
	MemorySize: jsii.Number(2048),
	AcceleratorConfig: &AcceleratorConfig{
		AcceleratorMemorySize: lambda.AcceleratorMemorySize_GIB_24(),
	},
})

gpuCapacityProvider.AddFunction(fn)
```

## Properties

- `GIB_12`: [AcceleratorMemorySize](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.AcceleratorMemorySize.html) (static) — 12 GiB of accelerator memory.

- `GIB_16`: [AcceleratorMemorySize](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.AcceleratorMemorySize.html) (static) — 16 GiB of accelerator memory.

- `GIB_24`: [AcceleratorMemorySize](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.AcceleratorMemorySize.html) (static) — 24 GiB of accelerator memory.

- `GIB_3`: [AcceleratorMemorySize](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.AcceleratorMemorySize.html) (static) — 3 GiB of accelerator memory.

- `GIB_48`: [AcceleratorMemorySize](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.AcceleratorMemorySize.html) (static) — 48 GiB of accelerator memory.

- `GIB_6`: [AcceleratorMemorySize](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda.AcceleratorMemorySize.html) (static) — 6 GiB of accelerator memory.

- `gibibytes`: number — The amount of accelerator memory in gibibytes (GiB).

  May be an unresolved token when supplied via `of()`.

## Methods

- `of(gibibytes: number): AcceleratorMemorySize // chainable` (static) — An amount of accelerator memory expressed as a number of gibibytes (GiB).

  Prefer the predefined constants; use this escape hatch only for a value the
  service supports that is not yet represented as a constant. The specific set
  of valid sizes is a service-side constraint enforced at deploy time, so this
  method does not restrict the value to the predefined constants. It does reject
  clearly-invalid input (a non-positive or non-integer number of GiB). The value
  may be an unresolved token, in which case validation is skipped.
