Struct Logger 

pub struct Logger { /* private fields */ }

Logger (real mode - uses Rust bridge)

Implementations

impl Logger

pub fn new<H: LogHandler + 'static>(handler: H) -> Result<Self>

pub fn stderr() -> Result<Self>

Examples found in repository

examples/basic_workflow.rs (line 29)

fn main() -> Result<(), Box<dyn Error>> {
    #[cfg(feature = "dlopen_tensorrt_rtx")]
    trtx::dynamically_load_tensorrt(None::<String>).unwrap();
    #[cfg(feature = "dlopen_tensorrt_onnxparser")]
    trtx::dynamically_load_tensorrt_onnxparser(None::<String>).unwrap();

    println!("TensorRT-RTX Basic Workflow Example");
    println!("=====================================\n");

    // Step 1: Create logger
    println!("1. Creating logger...");
    let logger = Logger::stderr()?;
    println!("   ✓ Logger created\n");

    // Step 2: Build phase
    println!("2. Building engine...");

    let builder = Builder::new(&logger)?;
    println!("   ✓ Builder created");

    // Create network with explicit batch dimensions
    let mut network = builder.create_network(network_flags::EXPLICIT_BATCH)?;
    println!("   ✓ Network created");

    // Create and configure builder config
    let mut config = builder.create_config()?;
    println!("   ✓ Config created");

    // Set workspace memory limit (1GB)
    config.set_memory_pool_limit(MemoryPoolType::Workspace, 1 << 30)?;
    println!("   ✓ Workspace limit set to 1GB");

    // Note: In a real application, you would add layers to the network here
    // For example:
    // - network.add_input(...)
    // - network.add_convolution(...)
    // - network.add_activation(...)
    // - etc.

    println!("\n   Note: This example uses an empty network.");
    println!("   In production, you would:");
    println!("   - Parse an ONNX model");
    println!("   - Or programmatically add layers");
    println!("   - Define input/output tensors\n");

    // Build serialized network
    println!("   Building serialized engine...");
    match builder.build_serialized_network(&mut network, &mut config) {
        Ok(engine_data) => {
            println!("   ✓ Engine built ({} bytes)", engine_data.len());

            // Save to disk
            let engine_path = "/tmp/example.engine";
            std::fs::write(engine_path, &engine_data)?;
            println!("   ✓ Engine saved to {}\n", engine_path);

            // Step 3: Inference phase
            println!("3. Loading engine for inference...");

            let runtime = Runtime::new(&logger)?;
            println!("   ✓ Runtime created");

            let engine = runtime.deserialize_cuda_engine(&engine_data)?;
            println!("   ✓ Engine deserialized");

            // Query engine information
            let num_tensors = engine.get_nb_io_tensors()?;
            println!("   ✓ Engine has {} I/O tensors", num_tensors);

            for i in 0..num_tensors {
                let name = engine.get_tensor_name(i)?;
                println!("      - Tensor {}: {}", i, name);
            }

            // Create execution context
            let _context = engine.create_execution_context()?;
            println!("   ✓ Execution context created\n");

            println!("4. Next steps for real inference:");
            println!("   - Allocate CUDA memory for inputs/outputs");
            println!("   - Copy input data to GPU");
            println!("   - Bind tensor addresses with context.set_tensor_address()");
            println!("   - Execute with context.enqueue_v3()");
            println!("   - Copy results back to CPU");
        }
        Err(e) => {
            eprintln!("   ✗ Failed to build engine: {}", e);
            eprintln!("\n   This is expected for an empty network.");
            eprintln!("   In production, add layers before building.");
            return Err(e.into());
        }
    }

    println!("\n✓ Example completed successfully!");

    Ok(())
}

examples/tiny_network.rs (line 28)

fn main() -> Result<()> {
    #[cfg(feature = "dlopen_tensorrt_rtx")]
    trtx::dynamically_load_tensorrt(None::<String>).unwrap();
    #[cfg(feature = "dlopen_tensorrt_onnxparser")]
    trtx::dynamically_load_tensorrt_onnxparser(None::<String>).unwrap();

    println!("=== Tiny Network Example ===\n");

    // 1. Create logger
    println!("1. Creating logger...");
    let logger = Logger::stderr()?;

    // 2. Build the network
    println!("2. Building network...");
    let engine_data = build_tiny_network(&logger)?;
    println!("   Engine size: {} bytes", engine_data.len());

    // 3. Create runtime and deserialize engine
    println!("\n3. Creating runtime and loading engine...");
    let runtime = Runtime::new(&logger)?;
    let engine = runtime.deserialize_cuda_engine(&engine_data)?;

    // 4. Inspect engine
    println!("4. Engine information:");
    let num_io_tensors = engine.get_nb_io_tensors()?;
    println!("   Number of I/O tensors: {}", num_io_tensors);

    for i in 0..num_io_tensors {
        let name = engine.get_tensor_name(i)?;
        println!("   Tensor {}: {}", i, name);
    }

    // 5. Create execution context
    println!("\n5. Creating execution context...");
    let mut context = engine.create_execution_context()?;

    // 6. Prepare input/output buffers
    println!("6. Preparing buffers...");
    let input_size = 3 * 4 * 4; // [1, 3, 4, 4]
    let output_size = 3 * 4 * 4; // Same as input

    // Create input with mix of positive and negative values
    let input_data: Vec<f32> = (0..input_size)
        .map(|i| {
            // Create pattern: positive, negative, zero, positive, ...
            match i % 4 {
                0 => (i as f32) * 0.5,  // Positive values
                1 => -(i as f32) * 0.3, // Negative values
                2 => 0.0,               // Zero
                _ => (i as f32) * 0.1,  // Small positive values
            }
        })
        .collect();

    println!("   Input shape: [1, 3, 4, 4] ({} elements)", input_size);
    println!("   First 8 input values: {:?}", &input_data[..8]);

    // Allocate device memory
    let mut input_device = DeviceBuffer::new(input_size * std::mem::size_of::<f32>())?;
    let output_device = DeviceBuffer::new(output_size * std::mem::size_of::<f32>())?;

    // Copy input to device (convert f32 slice to bytes)
    let input_bytes = unsafe {
        std::slice::from_raw_parts(
            input_data.as_ptr() as *const u8,
            input_data.len() * std::mem::size_of::<f32>(),
        )
    };
    input_device.copy_from_host(input_bytes)?;

    // 7. Set tensor addresses
    println!("\n7. Binding tensors...");
    unsafe {
        context.set_tensor_address("input", input_device.as_ptr())?;
        context.set_tensor_address("output", output_device.as_ptr())?;
    }

    // 8. Execute inference
    println!("8. Running inference...");
    let stream = trtx::cuda::get_default_stream();
    unsafe {
        context.enqueue_v3(stream)?;
    }
    synchronize()?;
    println!("   ✓ Inference completed");

    // 9. Copy output back to host
    println!("\n9. Reading results...");
    let mut output_data: Vec<f32> = vec![0.0; output_size];
    let output_bytes = unsafe {
        std::slice::from_raw_parts_mut(
            output_data.as_mut_ptr() as *mut u8,
            output_data.len() * std::mem::size_of::<f32>(),
        )
    };
    output_device.copy_to_host(output_bytes)?;

    println!("   Output shape: [1, 3, 4, 4] ({} elements)", output_size);
    println!("   First 8 output values: {:?}", &output_data[..8]);

    // 10. Verify results
    println!("\n10. Verification:");
    println!("   ReLU function: max(0, x)");
    println!("   - Positive inputs should pass through unchanged");
    println!("   - Negative inputs should become 0.0");
    println!("   - Zero inputs should remain 0.0");

    let mut passed = true;
    let mut failures = Vec::new();

    for (i, (&input, &output)) in input_data.iter().zip(output_data.iter()).enumerate() {
        let expected = if input > 0.0 { input } else { 0.0 };
        let diff = (output - expected).abs();

        if diff > 1e-6 {
            passed = false;
            if failures.len() < 5 {
                failures.push((i, input, expected, output));
            }
        }
    }

    if passed {
        println!(
            "\n   ✓ PASS: All {} outputs match expected ReLU behavior!",
            output_size
        );

        // Show some examples
        println!("\n   Sample verification (first 8 elements):");
        for i in 0..8.min(input_size) {
            let input = input_data[i];
            let output = output_data[i];
            let expected = if input > 0.0 { input } else { 0.0 };
            println!(
                "      [{:2}] ReLU({:7.3}) = {:7.3} (expected {:7.3}) ✓",
                i, input, output, expected
            );
        }
    } else {
        println!("\n   ✗ FAIL: {} mismatches found!", failures.len());
        for (i, input, expected, output) in failures {
            println!(
                "      [{:2}] ReLU({:7.3}) = {:7.3}, expected {:7.3}",
                i, input, output, expected
            );
        }
    }

    println!("\n=== Example completed ===");
    Ok(())
}

Trait Implementations

impl Drop for Logger

fn drop(&mut self)

Executes the destructor for this type.

impl Send for Logger

impl Sync for Logger