Performance Tuning Guide¶

use image::{DynamicImage, ImageBuffer};

fn preprocess_for_ocr(img: DynamicImage) -> DynamicImage {
    let mut processed = img
        .grayscale()  // Convert to grayscale
        .adjust_contrast(20.0)  // Increase contrast
        .brighten(10);  // Adjust brightness

    // Resize if too large (maintain aspect ratio)
    if processed.width() > 3000 {
        processed = processed.resize(
            3000,
            3000 * processed.height() / processed.width(),
            image::imageops::FilterType::Lanczos3
        );
    }

    // Apply denoising
    processed = denoise(processed, 2);

    // Deskew if needed
    if let Some(angle) = detect_skew(&processed) {
        if angle.abs() > 0.5 {
            processed = rotate(&processed, -angle);
        }
    }

    processed
}

use tokio::sync::Semaphore;
use std::sync::Arc;

async fn process_ocr_queue(pool: &PgPool, workers: usize) {
    let semaphore = Arc::new(Semaphore::new(workers));
    let mut tasks = Vec::new();

    loop {
        let permit = semaphore.clone().acquire_owned().await.unwrap();
        let pool_clone = pool.clone();

        let task = tokio::spawn(async move {
            if let Some(job) = fetch_next_ocr_job(&pool_clone).await {
                let _result = process_ocr_job(job, &pool_clone).await;
            }
            drop(permit);
        });

        tasks.push(task);

        // Clean up completed tasks
        tasks.retain(|task| !task.is_finished());

        tokio::time::sleep(Duration::from_millis(100)).await;
    }
}

// Implement object pooling for frequent allocations
use object_pool::{Pool, Reusable};

lazy_static! {
    static ref BUFFER_POOL: Pool<Vec<u8>> = Pool::new(32, || Vec::with_capacity(1024 * 1024));
}

async fn process_document(data: &[u8]) -> Result<()> {
    let mut buffer = BUFFER_POOL.pull();
    buffer.clear();
    buffer.extend_from_slice(data);

    // Process using pooled buffer
    let result = process(&buffer).await?;

    // Buffer automatically returned to pool when dropped
    Ok(result)
}

use sqlx::postgres::PgPoolOptions;

let pool = PgPoolOptions::new()
    .max_connections(32)  // Maximum connections
    .min_connections(5)   // Minimum idle connections
    .connect_timeout(Duration::from_secs(5))
    .acquire_timeout(Duration::from_secs(10))
    .idle_timeout(Duration::from_secs(600))
    .max_lifetime(Duration::from_secs(1800))
    .connect(&database_url)
    .await?;

use deadpool_redis::{Config, Runtime};

let cfg = Config {
    url: Some("redis://localhost:6379".to_string()),
    pool: Some(deadpool::managed::PoolConfig {
        max_size: 16,
        timeouts: deadpool::managed::Timeouts {
            wait: Some(Duration::from_secs(5)),
            create: Some(Duration::from_secs(5)),
            recycle: Some(Duration::from_secs(5)),
        },
        ..Default::default()
    }),
    ..Default::default()
};

let pool = cfg.create_pool(Some(Runtime::Tokio1))?;

use moka::future::Cache;
use std::time::Duration;

// L1 Cache: In-memory for hot data
lazy_static! {
    static ref L1_CACHE: Cache<String, Document> = Cache::builder()
        .max_capacity(1000)
        .time_to_live(Duration::from_secs(300))
        .build();
}

// L2 Cache: Redis for distributed caching
async fn get_document_cached(id: &str) -> Result<Document> {
    // Check L1 cache
    if let Some(doc) = L1_CACHE.get(id).await {
        return Ok(doc);
    }

    // Check L2 cache (Redis)
    if let Some(doc) = redis_get(id).await? {
        L1_CACHE.insert(id.to_string(), doc.clone()).await;
        return Ok(doc);
    }

    // Fetch from database
    let doc = fetch_from_db(id).await?;

    // Update caches
    L1_CACHE.insert(id.to_string(), doc.clone()).await;
    redis_set(id, &doc, 3600).await?;

    Ok(doc)
}