[profile.release]
opt-level = 3
lto = false
codegen-units = 16
strip = false

[profile.release]
opt-level = 3          # Maximum optimization
lto = "fat"           # Full link-time optimization
codegen-units = 1     # Better optimization, slower compile
strip = true          # Strip symbols
panic = "abort"       # Smaller binary, no unwinding

[profile.release]
opt-level = 3
lto = "thin"
codegen-units = 16

[profile.release]
opt-level = 3
lto = "fat"
codegen-units = 1

// benchmark.rs
use std::time::Instant;

fn main() {
    let iterations = 10_000_000;
    
    // Test function
    let start = Instant::now();
    for _ in 0..iterations {
        compute(42, 100);
    }
    let duration = start.elapsed();
    
    println!("Total time: {:?}", duration);
    println!("Per iteration: {:?}", duration / iterations);
}

fn compute(a: i32, b: i32) -> i32 {
    (a * b + a - b) / (b + 1)
}

[profile.release]
opt-level = "z"       # Optimize for size
lto = "fat"
codegen-units = 1
strip = true
panic = "abort"

// Enable PGO in build.rs
fn main() {
    println!("cargo:rustc-cfg=pgo_gen");
}

[profile.release]
pgo = "generate"

# Instead of tokio (full), use specific features
tokio = { version = "1", default-features = false, features = ["rt-multi-thread", "macros"] }

# Instead of serde (all formats), use what you need
serde = { version = "1", default-features = false, features = ["derive"] }
serde_json = "1"

# For logging, consider log + minimal implementation
log = "0.4"
env_logger = "0.10"  # Or use tracing with minimal features

# Default: pulls in many dependencies
axum = "0.7"

# Minimal: only what's needed
axum = { version = "0.7", default-features = false, features = ["macros", "tower-log"] }

# Show dependency tree
cargo tree --duplicates

# Show size of dependencies
cargo tree --size -t

# Count lines of code
cargo tree --duplicates | wc -l

[profile.release]
opt-level = "z"
lto = true
codegen-units = 1
strip = true
panic = "abort"

# Additional Lambda optimizations
[lib]
crate-type = ["cdylib", "rlib"]

use lambda_runtime::{run, service_fn, Error, LambdaEvent};
use serde::{Deserialize, Serialize};

#[derive(Deserialize)]
struct Request {
    name: String,
}

#[derive(Serialize)]
struct Response {
    message: String,
}

async fn function_handler(
    event: LambdaEvent<Request>,
) -> Result<Response, Error> {
    let name = event.payload.name;
    
    Ok(Response {
        message: format!("Hello, {}!", name),
    })
}

#[tokio::main]
async fn main() -> Result<(), Error> {
    run(service_fn(function_handler)).await
}

# Build stage
FROM rust:1.75 AS builder

WORKDIR /app

COPY Cargo.toml Cargo.lock ./
COPY src ./src

RUN cargo build --release --lib

# Runtime stage
FROM scratch

COPY --from=builder /app/target/release/libmy_lambda.so /var/task/libmy_lambda.so
COPY --from=builder /app/bootstrap /var/task/bootstrap

ENTRYPOINT ["/var/task/bootstrap"]

# Install target
rustup target add aarch64-unknown-linux-gnu

# Build
cargo build --release --target aarch64-unknown-linux-gnu

# Install WASM target
rustup target add wasm32-unknown-unknown

# Build
cargo build --release --target wasm32-unknown-unknown

# Convert to JavaScript
wasm-bindgen --out-dir ./out/ --target web ./target/wasm32-unknown-unknown/release/myapp.wasm

rustup target add armv7-unknown-linux-gnueabihf

# Requires cross-compilation toolchain
cargo build --release --target armv7-unknown-linux-gnueabihf

[profile.release]
strip = true

# Strip all symbols
strip target/release/myapp

# Strip debug symbols only (keep symbols for debugging)
strip --strip-debug target/release/myapp

# Remove symbol table entirely
strip --strip-all target/release/myapp

# Show sections
rust-size target/release/myapp

# Show dependencies
ldd target/release/myapp

# Show symbols
nm target/release/myapp | head -20

# Use sccache for faster builds
cargo install sccache

# Set environment
export RUSTC_WRAPPER=sccache
export SCCACHE_GHA_ENABLED=true

# Build
cargo build --release

// build.rs
fn main() {
    // Only rebuild if build.rs changes
    println!("cargo:rerun-if-changed=build.rs");
    println!("cargo:rerun-if-changed=src/config.rs");
    
    // Don't generate code at build time if not needed
    // Use compile-time macros instead
}

[profile.release]
opt-level = "z"
lto = true
codegen-units = 1

[package.metadata.wasm]
profile = "release"

# Install wasm-opt
cargo install wasm-bindgen-cli

# Run binaryen optimization
wasm-opt -Oz -o output.wasm input.wasm

use wasm_bindgen::prelude::*;

#[wasm_bindgen]
pub fn fibonacci(n: u32) -> u32 {
    match n {
        0 => 0,
        1 => 1,
        _ => {
            let mut a = 0u32;
            let mut b = 1u32;
            for _ in 2..=n {
                let temp = a + b;
                a = b;
                b = temp;
            }
            b
        }
    }
}

#![no_std]
#![no_main]

use core::panic::PanicInfo;

#[panic_handler]
fn panic(_info: &PanicInfo) -> ! {
    loop {}
}

#[no_mangle]
pub extern "C" fn main() {
    // Embedded application
}

[profile.release]
opt-level = "z"
lto = true
codegen-units = 1
strip = true

[target.thumbv7em-none-eabihf]
rustflags = [
    "-C", "link-arg=-Tlink.x",
    "-C", "target-cpu=cortex-m4",
]

#!/bin/bash
set -e

echo "Building for production..."

# Clean previous builds
cargo clean

# Build with optimizations
cargo build --release \
    --lib \
    --bin myapp \
    --locked

# Strip symbols
strip target/release/myapp

# Show final size
echo "Final binary size:"
ls -lh target/release/myapp

# Show section sizes
rust-size target/release/myapp

use std::time::Instant;

fn main() {
    // Fibonacci benchmark
    let iterations = 1000;
    
    // Release build comparison
    for profile in ["debug", "release"] {
        let start = Instant::now();
        for _ in 0..iterations {
            let _ = fibonacci(30);
        }
        println!("{}: {:?}", profile, start.elapsed());
    }
}

fn fibonacci(n: u32) -> u32 {
    match n {
        0 => 0,
        1 => 1,
        _ => fibonacci(n - 1) + fibonacci(n - 2),
    }
}