Struct PlanMany 

pub struct PlanMany { /* private fields */ }

A batched / many-rank plan (cufftPlanMany). Handles arbitrary rank + advanced-data-layout transforms.

Implementations

impl PlanMany

pub fn new( rank: i32, n: &mut [i32], inembed: Option<&mut [i32]>, istride: i32, idist: i32, onembed: Option<&mut [i32]>, ostride: i32, odist: i32, ty: Transform, batch: i32, ) -> Result<Self>

Construct a batched plan. n[rank] is the transform shape; inembed / onembed are the actual memory layouts of in/out (pass None for packed). istride/ostride are element strides between successive elements; idist/odist are element strides between successive batches.

Example

32 packed 1-D R2C transforms of length 256 (e.g., a STFT frame).

use baracuda_driver::{Context, Device, DeviceBuffer};
use baracuda_cufft::{PlanMany, Transform};
use baracuda_types::Complex32;

let ctx = Context::new(&Device::get(0)?)?;
let n_per = 256i32;
let batch = 32i32;
let mut n = [n_per];

// Packed contiguous layout: pass None for embeds, strides = 1, dist = transform length.
let plan = PlanMany::new(
    /* rank   */ 1,
    /* n      */ &mut n,
    /* inemb  */ None,
    /* istr   */ 1,
    /* idist  */ n_per,
    /* onemb  */ None,
    /* ostr   */ 1,
    /* odist  */ n_per / 2 + 1,
    /* type   */ Transform::R2C,
    /* batch  */ batch,
)?;

let mut input:  DeviceBuffer<f32>       =
    DeviceBuffer::zeros(&ctx, (n_per * batch) as usize)?;
let mut output: DeviceBuffer<Complex32> =
    DeviceBuffer::new(&ctx, ((n_per / 2 + 1) * batch) as usize)?;
plan.exec_r2c(&mut input, &mut output)?;

pub fn as_raw(&self) -> cufftHandle

Raw cufftHandle. Use with care.

pub fn set_stream(&self, stream: &Stream) -> Result<()>

Bind the plan to a CUDA stream.

impl PlanMany

pub fn exec_d2z( &self, input: &mut DeviceBuffer<f64>, output: &mut DeviceBuffer<Complex64>, ) -> Result<()>

Execute D → Z (double-precision R2C). Plan must have been built with Transform::D2Z.

pub fn exec_z2d( &self, input: &mut DeviceBuffer<Complex64>, output: &mut DeviceBuffer<f64>, ) -> Result<()>

Execute Z → D (double-precision C2R).

pub fn exec_z2z( &self, input: &mut DeviceBuffer<Complex64>, output: &mut DeviceBuffer<Complex64>, direction: Direction, ) -> Result<()>

Execute Z → Z (double-precision C2C). Direction passed at exec time.

impl PlanMany

pub fn exec_r2c( &self, input: &mut DeviceBuffer<f32>, output: &mut DeviceBuffer<Complex32>, ) -> Result<()>

Execute R → C (single-precision R2C).

pub fn exec_c2r( &self, input: &mut DeviceBuffer<Complex32>, output: &mut DeviceBuffer<f32>, ) -> Result<()>

Execute C → R (single-precision C2R).

pub fn exec_c2c( &self, input: &mut DeviceBuffer<Complex32>, output: &mut DeviceBuffer<Complex32>, direction: Direction, ) -> Result<()>

Execute C → C.

Trait Implementations

impl Debug for PlanMany

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for PlanMany

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.